
(/VERSIONCHECK 2) 

(PUT '|ULSCONS;getExpon| '|SPADreplace| 'QCAR) 

(DEFUN |ULSCONS;getExpon| (|x| $) (QCAR |x|)) 

(PUT '|ULSCONS;getUTS| '|SPADreplace| 'QCDR) 

(DEFUN |ULSCONS;getUTS| (|x| $) (QCDR |x|)) 

(PUT '|ULSCONS;laurent;IUTS$;3| '|SPADreplace| 'CONS) 

(DEFUN |ULSCONS;laurent;IUTS$;3| (|n| |psr| $) (CONS |n| |psr|)) 

(DEFUN |ULSCONS;taylorRep;$UTS;4| (|x| $) (|ULSCONS;getUTS| |x| $)) 

(DEFUN |ULSCONS;degree;$I;5| (|x| $) (|ULSCONS;getExpon| |x| $)) 

(DEFUN |ULSCONS;Zero;$;6| ($) (SPADCALL 0 (|spadConstant| $ 15) (QREFELT $ 10))) 

(DEFUN |ULSCONS;One;$;7| ($) (SPADCALL 0 (|spadConstant| $ 16) (QREFELT $ 10))) 

(DEFUN |ULSCONS;monomial;CoefI$;8| (|s| |e| $)
  (SPADCALL |e| (SPADCALL |s| (QREFELT $ 18)) (QREFELT $ 10))) 

(DEFUN |ULSCONS;coerce;UTS$;9| (|uts| $) (SPADCALL 0 |uts| (QREFELT $ 10))) 

(DEFUN |ULSCONS;coerce;Coef$;10| (|r| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 18)) (QREFELT $ 20))) 

(DEFUN |ULSCONS;coerce;I$;11| (|i| $)
  (SPADCALL (SPADCALL |i| (QREFELT $ 22)) (QREFELT $ 21))) 

(DEFUN |ULSCONS;taylorIfCan;$U;12| (|uls| $)
  (PROG (#1=#:G726 |n|)
    (RETURN
     (SEQ
      (LETT |n| (|ULSCONS;getExpon| |uls| $)
            . #2=(|ULSCONS;taylorIfCan;$U;12|))
      (EXIT
       (COND
        ((< |n| 0)
         (SEQ (LETT |uls| (SPADCALL (- |n|) |uls| (QREFELT $ 24)) . #2#)
              (EXIT
               (COND ((< (|ULSCONS;getExpon| |uls| $) 0) (CONS 1 "failed"))
                     (#3='T (CONS 0 (|ULSCONS;getUTS| |uls| $)))))))
        ((EQL |n| 0) (CONS 0 (|ULSCONS;getUTS| |uls| $)))
        (#3#
         (CONS 0
               (SPADCALL (|ULSCONS;getUTS| |uls| $)
                         (SPADCALL (|spadConstant| $ 25)
                                   (PROG1 (LETT #1# |n| . #2#)
                                     (|check-subtype| (>= #1# 0)
                                                      '(|NonNegativeInteger|)
                                                      #1#))
                                   (QREFELT $ 27))
                         (QREFELT $ 28)))))))))) 

(DEFUN |ULSCONS;taylor;$UTS;13| (|uls| $)
  (PROG (|uts|)
    (RETURN
     (SEQ (LETT |uts| (SPADCALL |uls| (QREFELT $ 30)) |ULSCONS;taylor;$UTS;13|)
          (EXIT
           (COND
            ((QEQCAR |uts| 1) (|error| "taylor: Laurent series has a pole"))
            ('T (QCDR |uts|)))))))) 

(PUT '|ULSCONS;termExpon| '|SPADreplace| 'QCAR) 

(DEFUN |ULSCONS;termExpon| (|term| $) (QCAR |term|)) 

(PUT '|ULSCONS;termCoef| '|SPADreplace| 'QCDR) 

(DEFUN |ULSCONS;termCoef| (|term| $) (QCDR |term|)) 

(PUT '|ULSCONS;rec| '|SPADreplace| 'CONS) 

(DEFUN |ULSCONS;rec| (|exponent| |coef| $) (CONS |exponent| |coef|)) 

(DEFUN |ULSCONS;recs| (|st| |n| $)
  (PROG ()
    (RETURN
     (SPADCALL (CONS #'|ULSCONS;recs!0| (VECTOR |n| $ |st|)) (QREFELT $ 45))))) 

(DEFUN |ULSCONS;recs!0| ($$)
  (PROG (|st| $ |n|)
    (LETT |st| (QREFELT $$ 2) . #1=(|ULSCONS;recs|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |n| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|coef|)
        (RETURN
         (COND ((SPADCALL |st| (QREFELT $ 34)) (SPADCALL (QREFELT $ 37)))
               ((SPADCALL (LETT |coef| (SPADCALL |st| (QREFELT $ 38)) NIL)
                          (QREFELT $ 39))
                (|ULSCONS;recs| (SPADCALL |st| (QREFELT $ 40))
                 (SPADCALL |n| (|spadConstant| $ 41) (QREFELT $ 42)) $))
               ('T
                (SPADCALL (|ULSCONS;rec| |n| |coef| $)
                          (|ULSCONS;recs| (SPADCALL |st| (QREFELT $ 40))
                           (SPADCALL |n| (|spadConstant| $ 41) (QREFELT $ 42))
                           $)
                          (QREFELT $ 43)))))))))) 

(DEFUN |ULSCONS;terms;$S;18| (|x| $)
  (|ULSCONS;recs| (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 46))
   (|ULSCONS;getExpon| |x| $) $)) 

(DEFUN |ULSCONS;recsToCoefs| (|st| |n| $)
  (PROG ()
    (RETURN
     (SEQ
      (SPADCALL (CONS #'|ULSCONS;recsToCoefs!0| (VECTOR |n| $ |st|))
                (QREFELT $ 55)))))) 

(DEFUN |ULSCONS;recsToCoefs!0| ($$)
  (PROG (|st| $ |n|)
    (LETT |st| (QREFELT $$ 2) . #1=(|ULSCONS;recsToCoefs|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |n| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (PROG (|term| |ex|)
        (RETURN
         (SEQ
          (COND ((SPADCALL |st| (QREFELT $ 48)) (SPADCALL (QREFELT $ 49)))
                ('T
                 (SEQ (LETT |term| (SPADCALL |st| (QREFELT $ 50)) NIL)
                      (LETT |ex| (|ULSCONS;termExpon| |term| $) NIL)
                      (EXIT
                       (COND
                        ((SPADCALL |n| |ex| (QREFELT $ 51))
                         (SPADCALL (|ULSCONS;termCoef| |term| $)
                                   (|ULSCONS;recsToCoefs|
                                    (SPADCALL |st| (QREFELT $ 52))
                                    (SPADCALL |n| (|spadConstant| $ 41)
                                              (QREFELT $ 42))
                                    $)
                                   (QREFELT $ 53)))
                        ('T
                         (SPADCALL (|spadConstant| $ 14)
                                   (|ULSCONS;recsToCoefs|
                                    (SPADCALL |st| (QREFELT $ 52))
                                    (SPADCALL |n| (|spadConstant| $ 41)
                                              (QREFELT $ 42))
                                    $)
                                   (QREFELT $ 53))))))))))))))) 

(DEFUN |ULSCONS;series;S$;20| (|st| $)
  (PROG (|ex|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |st| (QREFELT $ 48)) (|spadConstant| $ 13))
            ('T
             (SEQ
              (LETT |ex| (|ULSCONS;termExpon| (SPADCALL |st| (QREFELT $ 50)) $)
                    |ULSCONS;series;S$;20|)
              (EXIT
               (SPADCALL |ex|
                         (SPADCALL (|ULSCONS;recsToCoefs| |st| |ex| $)
                                   (QREFELT $ 56))
                         (QREFELT $ 10)))))))))) 

(DEFUN |ULSCONS;removeZeroes;2$;21| (|x| $)
  (PROG (|xUTS|)
    (RETURN
     (COND
      ((SPADCALL
        (SPADCALL
         (LETT |xUTS| (|ULSCONS;getUTS| |x| $) |ULSCONS;removeZeroes;2$;21|)
         (QREFELT $ 46))
        (QREFELT $ 34))
       (|spadConstant| $ 13))
      ((SPADCALL (SPADCALL |xUTS| 0 (QREFELT $ 58)) (|spadConstant| $ 14)
                 (QREFELT $ 59))
       (SPADCALL
        (SPADCALL (+ (|ULSCONS;getExpon| |x| $) 1)
                  (SPADCALL |xUTS| (QREFELT $ 60)) (QREFELT $ 10))
        (QREFELT $ 61)))
      ('T |x|))))) 

(DEFUN |ULSCONS;removeZeroes;I2$;22| (|n| |x| $)
  (PROG (|xUTS|)
    (RETURN
     (COND
      ((< 0 |n|)
       (COND
        ((SPADCALL
          (SPADCALL
           (LETT |xUTS| (|ULSCONS;getUTS| |x| $) |ULSCONS;removeZeroes;I2$;22|)
           (QREFELT $ 46))
          (QREFELT $ 34))
         (|spadConstant| $ 13))
        ((SPADCALL (SPADCALL |xUTS| 0 (QREFELT $ 58)) (|spadConstant| $ 14)
                   (QREFELT $ 59))
         (SPADCALL (- |n| 1)
                   (SPADCALL (+ (|ULSCONS;getExpon| |x| $) 1)
                             (SPADCALL |xUTS| (QREFELT $ 60)) (QREFELT $ 10))
                   (QREFELT $ 24)))
        (#1='T |x|)))
      (#1# |x|))))) 

(DEFUN |ULSCONS;=;2$B;23| (|x| |y| $)
  (PROG (#1=#:G802 #2=#:G793 |expDiff|)
    (RETURN
     (SEQ
      (COND ((EQ |x| |y|) 'T)
            (#3='T
             (SEQ
              (LETT |expDiff|
                    (- (|ULSCONS;getExpon| |x| $) (|ULSCONS;getExpon| |y| $))
                    . #4=(|ULSCONS;=;2$B;23|))
              (EXIT
               (COND
                ((EQL |expDiff| 0)
                 (SPADCALL (|ULSCONS;getUTS| |x| $) (|ULSCONS;getUTS| |y| $)
                           (QREFELT $ 62)))
                ((< |$streamCount| (ABS |expDiff|)) 'NIL)
                ((< 0 |expDiff|)
                 (SPADCALL
                  (SPADCALL (|ULSCONS;getUTS| |x| $)
                            (SPADCALL (|spadConstant| $ 25)
                                      (PROG1 (LETT #2# |expDiff| . #4#)
                                        (|check-subtype| (>= #2# 0)
                                                         '(|NonNegativeInteger|)
                                                         #2#))
                                      (QREFELT $ 27))
                            (QREFELT $ 28))
                  (|ULSCONS;getUTS| |y| $) (QREFELT $ 62)))
                (#3#
                 (SPADCALL
                  (SPADCALL (|ULSCONS;getUTS| |y| $)
                            (SPADCALL (|spadConstant| $ 25)
                                      (PROG1 (LETT #1# (- |expDiff|) . #4#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))
                                      (QREFELT $ 27))
                            (QREFELT $ 28))
                  (|ULSCONS;getUTS| |x| $) (QREFELT $ 62)))))))))))) 

(DEFUN |ULSCONS;pole?;$B;24| (|x| $)
  (PROG (#1=#:G809 |n|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |n| (SPADCALL |x| (QREFELT $ 12)) . #2=(|ULSCONS;pole?;$B;24|))
         (EXIT
          (COND ((NULL (< |n| 0)) (PROGN (LETT #1# 'NIL . #2#) (GO #1#))))))
        (LETT |x| (SPADCALL (- |n|) |x| (QREFELT $ 24)) . #2#)
        (EXIT (< (SPADCALL |x| (QREFELT $ 12)) 0))))
      #1# (EXIT #1#))))) 

(DEFUN |ULSCONS;+;3$;25| (|x| |y| $)
  (PROG (#1=#:G813 #2=#:G812 |n|)
    (RETURN
     (SEQ
      (LETT |n| (- (|ULSCONS;getExpon| |x| $) (|ULSCONS;getExpon| |y| $))
            . #3=(|ULSCONS;+;3$;25|))
      (EXIT
       (COND
        ((< |n| 0)
         (SPADCALL (|ULSCONS;getExpon| |x| $)
                   (SPADCALL (|ULSCONS;getUTS| |x| $)
                             (SPADCALL (|ULSCONS;getUTS| |y| $)
                                       (SPADCALL (|spadConstant| $ 25)
                                                 (PROG1
                                                     (LETT #2# (- |n|) . #3#)
                                                   (|check-subtype| (>= #2# 0)
                                                                    '(|NonNegativeInteger|)
                                                                    #2#))
                                                 (QREFELT $ 27))
                                       (QREFELT $ 28))
                             (QREFELT $ 65))
                   (QREFELT $ 10)))
        ('T
         (SPADCALL (|ULSCONS;getExpon| |y| $)
                   (SPADCALL (|ULSCONS;getUTS| |y| $)
                             (SPADCALL (|ULSCONS;getUTS| |x| $)
                                       (SPADCALL (|spadConstant| $ 25)
                                                 (PROG1 (LETT #1# |n| . #3#)
                                                   (|check-subtype| (>= #1# 0)
                                                                    '(|NonNegativeInteger|)
                                                                    #1#))
                                                 (QREFELT $ 27))
                                       (QREFELT $ 28))
                             (QREFELT $ 65))
                   (QREFELT $ 10))))))))) 

(DEFUN |ULSCONS;-;3$;26| (|x| |y| $)
  (PROG (#1=#:G818 #2=#:G817 |n|)
    (RETURN
     (SEQ
      (LETT |n| (- (|ULSCONS;getExpon| |x| $) (|ULSCONS;getExpon| |y| $))
            . #3=(|ULSCONS;-;3$;26|))
      (EXIT
       (COND
        ((< |n| 0)
         (SPADCALL (|ULSCONS;getExpon| |x| $)
                   (SPADCALL (|ULSCONS;getUTS| |x| $)
                             (SPADCALL (|ULSCONS;getUTS| |y| $)
                                       (SPADCALL (|spadConstant| $ 25)
                                                 (PROG1
                                                     (LETT #2# (- |n|) . #3#)
                                                   (|check-subtype| (>= #2# 0)
                                                                    '(|NonNegativeInteger|)
                                                                    #2#))
                                                 (QREFELT $ 27))
                                       (QREFELT $ 28))
                             (QREFELT $ 67))
                   (QREFELT $ 10)))
        ('T
         (SPADCALL (|ULSCONS;getExpon| |y| $)
                   (SPADCALL
                    (SPADCALL (|ULSCONS;getUTS| |x| $)
                              (SPADCALL (|spadConstant| $ 25)
                                        (PROG1 (LETT #1# |n| . #3#)
                                          (|check-subtype| (>= #1# 0)
                                                           '(|NonNegativeInteger|)
                                                           #1#))
                                        (QREFELT $ 27))
                              (QREFELT $ 28))
                    (|ULSCONS;getUTS| |y| $) (QREFELT $ 67))
                   (QREFELT $ 10))))))))) 

(DEFUN |ULSCONS;*;3$;27| (|x| |y| $)
  (SPADCALL (+ (|ULSCONS;getExpon| |x| $) (|ULSCONS;getExpon| |y| $))
            (SPADCALL (|ULSCONS;getUTS| |x| $) (|ULSCONS;getUTS| |y| $)
                      (QREFELT $ 28))
            (QREFELT $ 10))) 

(DEFUN |ULSCONS;^;$Nni$;28| (|x| |n| $)
  (COND
   ((ZEROP |n|)
    (COND ((SPADCALL |x| (QREFELT $ 70)) (|error| "0 ^ 0 is undefined"))
          (#1='T (|spadConstant| $ 17))))
   (#1#
    (SPADCALL (SPADCALL |n| (|ULSCONS;getExpon| |x| $) (QREFELT $ 71))
              (SPADCALL (|ULSCONS;getUTS| |x| $) |n| (QREFELT $ 72))
              (QREFELT $ 10))))) 

(DEFUN |ULSCONS;recip;$U;29| (|x| $)
  (PROG (|uts| |d|)
    (RETURN
     (SEQ
      (LETT |x| (SPADCALL 1000 |x| (QREFELT $ 24))
            . #1=(|ULSCONS;recip;$U;29|))
      (EXIT
       (COND
        ((SPADCALL
          (SPADCALL |x| (LETT |d| (SPADCALL |x| (QREFELT $ 12)) . #1#)
                    (QREFELT $ 74))
          (QREFELT $ 39))
         (CONS 1 "failed"))
        (#2='T
         (SEQ
          (LETT |uts| (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 76)) . #1#)
          (EXIT
           (COND ((QEQCAR |uts| 1) (CONS 1 "failed"))
                 (#2#
                  (CONS 0
                        (SPADCALL (- |d|) (QCDR |uts|)
                                  (QREFELT $ 10)))))))))))))) 

(DEFUN |ULSCONS;elt;3$;30| (|uls1| |uls2| $)
  (PROG (#1=#:G848 |uts1| |recipr| |deg| |uts2| |uts|)
    (RETURN
     (SEQ
      (LETT |uts| (SPADCALL |uls2| (QREFELT $ 30)) . #2=(|ULSCONS;elt;3$;30|))
      (EXIT
       (COND
        ((QEQCAR |uts| 1)
         (|error| "elt: second argument must have positive order"))
        (#3='T
         (SEQ (LETT |uts2| (QCDR |uts|) . #2#)
              (COND
               ((NULL
                 (SPADCALL (SPADCALL |uts2| 0 (QREFELT $ 58)) (QREFELT $ 39)))
                (EXIT
                 (|error| "elt: second argument must have positive order"))))
              (SEQ (LETT |deg| (|ULSCONS;getExpon| |uls1| $) . #2#)
                   (EXIT
                    (COND
                     ((< |deg| 0)
                      (LETT |uls1| (SPADCALL (- |deg|) |uls1| (QREFELT $ 24))
                            . #2#)))))
              (LETT |deg| (|ULSCONS;getExpon| |uls1| $) . #2#)
              (EXIT
               (COND
                ((< |deg| 0)
                 (SEQ
                  (LETT |recipr|
                        (SPADCALL (SPADCALL |uts2| (QREFELT $ 20))
                                  (QREFELT $ 77))
                        . #2#)
                  (EXIT
                   (COND
                    ((QEQCAR |recipr| 1)
                     (|error| "elt: second argument not invertible"))
                    (#3#
                     (SEQ
                      (LETT |uts1|
                            (SPADCALL
                             (SPADCALL |uls1|
                                       (SPADCALL (|spadConstant| $ 25)
                                                 (- |deg|) (QREFELT $ 19))
                                       (QREFELT $ 69))
                             (QREFELT $ 31))
                            . #2#)
                      (EXIT
                       (SPADCALL
                        (SPADCALL (SPADCALL |uts1| |uts2| (QREFELT $ 78))
                                  (QREFELT $ 20))
                        (SPADCALL (QCDR |recipr|)
                                  (PROG1 (LETT #1# (- |deg|) . #2#)
                                    (|check-subtype| (>= #1# 0)
                                                     '(|NonNegativeInteger|)
                                                     #1#))
                                  (QREFELT $ 73))
                        (QREFELT $ 69)))))))))
                (#3#
                 (SPADCALL
                  (SPADCALL (SPADCALL |uls1| (QREFELT $ 31)) |uts2|
                            (QREFELT $ 78))
                  (QREFELT $ 20))))))))))))) 

(DEFUN |ULSCONS;eval;$CoefS;31| (|uls| |r| $)
  (PROG (#1=#:G865 #2=#:G860 |recipr| |n| |uts|)
    (RETURN
     (SEQ
      (SEQ
       (LETT |n| (|ULSCONS;getExpon| |uls| $) . #3=(|ULSCONS;eval;$CoefS;31|))
       (EXIT
        (COND
         ((< |n| 0)
          (LETT |uls| (SPADCALL (- |n|) |uls| (QREFELT $ 24)) . #3#)))))
      (LETT |uts| (|ULSCONS;getUTS| |uls| $) . #3#)
      (LETT |n| (|ULSCONS;getExpon| |uls| $) . #3#)
      (EXIT
       (COND
        ((< |n| 0)
         (COND
          ((SPADCALL |r| (QREFELT $ 39))
           (|error| "eval: 0 raised to negative power"))
          (#4='T
           (SEQ (LETT |recipr| (SPADCALL |r| (QREFELT $ 80)) . #3#)
                (EXIT
                 (COND
                  ((QEQCAR |recipr| 1)
                   (|error| "eval: non-unit raised to negative power"))
                  (#4#
                   (SPADCALL
                    (SPADCALL (QCDR |recipr|)
                              (PROG1 (LETT #2# (- |n|) . #3#)
                                (|check-subtype| (>= #2# 0)
                                                 '(|NonNegativeInteger|) #2#))
                              (QREFELT $ 81))
                    (SPADCALL |uts| |r| (QREFELT $ 82)) (QREFELT $ 84)))))))))
        ((ZEROP |n|) (SPADCALL |uts| |r| (QREFELT $ 82)))
        (#4#
         (SPADCALL
          (SPADCALL |r|
                    (PROG1 (LETT #1# |n| . #3#)
                      (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                    (QREFELT $ 81))
          (SPADCALL |uts| |r| (QREFELT $ 82)) (QREFELT $ 84))))))))) 

(DEFUN |ULSCONS;variable;$S;32| (|x| $)
  (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 87))) 

(DEFUN |ULSCONS;center;$Coef;33| (|x| $)
  (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 89))) 

(DEFUN |ULSCONS;coefficient;$ICoef;34| (|x| |n| $)
  (PROG (#1=#:G874 |a|)
    (RETURN
     (SEQ
      (LETT |a| (- |n| (|ULSCONS;getExpon| |x| $))
            . #2=(|ULSCONS;coefficient;$ICoef;34|))
      (EXIT
       (COND ((< |a| 0) (|spadConstant| $ 14))
             ('T
              (SPADCALL (|ULSCONS;getUTS| |x| $)
                        (PROG1 (LETT #1# |a| . #2#)
                          (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                           #1#))
                        (QREFELT $ 58))))))))) 

(DEFUN |ULSCONS;elt;$ICoef;35| (|x| |n| $) (SPADCALL |x| |n| (QREFELT $ 74))) 

(DEFUN |ULSCONS;order;$I;36| (|x| $)
  (+ (|ULSCONS;getExpon| |x| $)
     (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 92)))) 

(DEFUN |ULSCONS;order;$2I;37| (|x| |n| $)
  (PROG (#1=#:G881 |m| |e|)
    (RETURN
     (SEQ
      (LETT |m|
            (- |n|
               (LETT |e| (|ULSCONS;getExpon| |x| $)
                     . #2=(|ULSCONS;order;$2I;37|)))
            . #2#)
      (EXIT
       (COND ((< |m| 0) |n|)
             ('T
              (+ |e|
                 (SPADCALL (|ULSCONS;getUTS| |x| $)
                           (PROG1 (LETT #1# |m| . #2#)
                             (|check-subtype| (>= #1# 0)
                                              '(|NonNegativeInteger|) #1#))
                           (QREFELT $ 94)))))))))) 

(DEFUN |ULSCONS;truncate;$I$;38| (|x| |n| $)
  (PROG (#1=#:G884 |m| |e|)
    (RETURN
     (SEQ
      (LETT |m|
            (- |n|
               (LETT |e| (|ULSCONS;getExpon| |x| $)
                     . #2=(|ULSCONS;truncate;$I$;38|)))
            . #2#)
      (EXIT
       (COND ((< |m| 0) (|spadConstant| $ 13))
             ('T
              (SPADCALL |e|
                        (SPADCALL (|ULSCONS;getUTS| |x| $)
                                  (PROG1 (LETT #1# |m| . #2#)
                                    (|check-subtype| (>= #1# 0)
                                                     '(|NonNegativeInteger|)
                                                     #1#))
                                  (QREFELT $ 96))
                        (QREFELT $ 10))))))))) 

(DEFUN |ULSCONS;truncate;$2I$;39| (|x| |n1| |n2| $)
  (PROG (#1=#:G888 #2=#:G887 |m1| |e| |#G61| |#G60|)
    (RETURN
     (SEQ
      (COND
       ((< |n2| |n1|)
        (PROGN
         (LETT |#G60| |n2| . #3=(|ULSCONS;truncate;$2I$;39|))
         (LETT |#G61| |n1| . #3#)
         (LETT |n1| |#G60| . #3#)
         (LETT |n2| |#G61| . #3#))))
      (LETT |m1| (- |n1| (LETT |e| (|ULSCONS;getExpon| |x| $) . #3#)) . #3#)
      (EXIT
       (COND ((< |m1| 0) (SPADCALL |x| |n2| (QREFELT $ 97)))
             ('T
              (SPADCALL |e|
                        (SPADCALL (|ULSCONS;getUTS| |x| $)
                                  (PROG1 (LETT #2# |m1| . #3#)
                                    (|check-subtype| (>= #2# 0)
                                                     '(|NonNegativeInteger|)
                                                     #2#))
                                  (PROG1 (LETT #1# (- |n2| |e|) . #3#)
                                    (|check-subtype| (>= #1# 0)
                                                     '(|NonNegativeInteger|)
                                                     #1#))
                                  (QREFELT $ 98))
                        (QREFELT $ 10))))))))) 

(DEFUN |ULSCONS;rationalFunction;$IF;40| (|x| |n| $)
  (PROG (#1=#:G896 #2=#:G895 |c| |v| |poly| #3=#:G892 |m| |e|)
    (RETURN
     (SEQ
      (LETT |m|
            (- |n|
               (LETT |e| (|ULSCONS;getExpon| |x| $)
                     . #4=(|ULSCONS;rationalFunction;$IF;40|)))
            . #4#)
      (EXIT
       (COND ((< |m| 0) (|spadConstant| $ 101))
             (#5='T
              (SEQ
               (LETT |poly|
                     (SPADCALL
                      (SPADCALL (|ULSCONS;getUTS| |x| $)
                                (PROG1 (LETT #3# |m| . #4#)
                                  (|check-subtype| (>= #3# 0)
                                                   '(|NonNegativeInteger|)
                                                   #3#))
                                (QREFELT $ 103))
                      (QREFELT $ 104))
                     . #4#)
               (EXIT
                (COND ((ZEROP |e|) |poly|)
                      (#5#
                       (SEQ
                        (LETT |v|
                              (SPADCALL (SPADCALL |x| (QREFELT $ 88))
                                        (QREFELT $ 105))
                              . #4#)
                        (LETT |c|
                              (SPADCALL
                               (SPADCALL (SPADCALL |x| (QREFELT $ 90))
                                         (QREFELT $ 106))
                               (QREFELT $ 104))
                              . #4#)
                        (EXIT
                         (COND
                          ((SPADCALL |e| (QREFELT $ 107))
                           (SPADCALL |poly|
                                     (SPADCALL
                                      (SPADCALL |v| |c| (QREFELT $ 108))
                                      (PROG1 (LETT #2# |e| . #4#)
                                        (|check-subtype| (>= #2# 0)
                                                         '(|NonNegativeInteger|)
                                                         #2#))
                                      (QREFELT $ 109))
                                     (QREFELT $ 110)))
                          (#5#
                           (SPADCALL |poly|
                                     (SPADCALL
                                      (SPADCALL |v| |c| (QREFELT $ 108))
                                      (PROG1 (LETT #1# (- |e|) . #4#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))
                                      (QREFELT $ 109))
                                     (QREFELT $ 111))))))))))))))))) 

(DEFUN |ULSCONS;rationalFunction;$2IF;41| (|x| |n1| |n2| $)
  (PROG (#1=#:G908 #2=#:G907 |c| |v| |poly| #3=#:G904 #4=#:G903 |m1| |e| |#G68|
         |#G67|)
    (RETURN
     (SEQ
      (COND
       ((< |n2| |n1|)
        (PROGN
         (LETT |#G67| |n2| . #5=(|ULSCONS;rationalFunction;$2IF;41|))
         (LETT |#G68| |n1| . #5#)
         (LETT |n1| |#G67| . #5#)
         (LETT |n2| |#G68| . #5#))))
      (LETT |m1| (- |n1| (LETT |e| (|ULSCONS;getExpon| |x| $) . #5#)) . #5#)
      (EXIT
       (COND ((< |m1| 0) (SPADCALL |x| |n2| (QREFELT $ 112)))
             (#6='T
              (SEQ
               (LETT |poly|
                     (SPADCALL
                      (SPADCALL (|ULSCONS;getUTS| |x| $)
                                (PROG1 (LETT #4# |m1| . #5#)
                                  (|check-subtype| (>= #4# 0)
                                                   '(|NonNegativeInteger|)
                                                   #4#))
                                (PROG1 (LETT #3# (- |n2| |e|) . #5#)
                                  (|check-subtype| (>= #3# 0)
                                                   '(|NonNegativeInteger|)
                                                   #3#))
                                (QREFELT $ 113))
                      (QREFELT $ 104))
                     . #5#)
               (EXIT
                (COND ((ZEROP |e|) |poly|)
                      (#6#
                       (SEQ
                        (LETT |v|
                              (SPADCALL (SPADCALL |x| (QREFELT $ 88))
                                        (QREFELT $ 105))
                              . #5#)
                        (LETT |c|
                              (SPADCALL
                               (SPADCALL (SPADCALL |x| (QREFELT $ 90))
                                         (QREFELT $ 106))
                               (QREFELT $ 104))
                              . #5#)
                        (EXIT
                         (COND
                          ((SPADCALL |e| (QREFELT $ 107))
                           (SPADCALL |poly|
                                     (SPADCALL
                                      (SPADCALL |v| |c| (QREFELT $ 108))
                                      (PROG1 (LETT #2# |e| . #5#)
                                        (|check-subtype| (>= #2# 0)
                                                         '(|NonNegativeInteger|)
                                                         #2#))
                                      (QREFELT $ 109))
                                     (QREFELT $ 110)))
                          (#6#
                           (SPADCALL |poly|
                                     (SPADCALL
                                      (SPADCALL |v| |c| (QREFELT $ 108))
                                      (PROG1 (LETT #1# (- |e|) . #5#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))
                                      (QREFELT $ 109))
                                     (QREFELT $ 111))))))))))))))))) 

(DEFUN |ULSCONS;exquo;2$U;42| (|x| |y| $)
  (PROG (|uts| |d|)
    (RETURN
     (SEQ
      (LETT |x| (SPADCALL 1000 |x| (QREFELT $ 24))
            . #1=(|ULSCONS;exquo;2$U;42|))
      (LETT |y| (SPADCALL 1000 |y| (QREFELT $ 24)) . #1#)
      (EXIT
       (COND
        ((SPADCALL
          (SPADCALL |y| (LETT |d| (SPADCALL |y| (QREFELT $ 12)) . #1#)
                    (QREFELT $ 74))
          (QREFELT $ 39))
         (CONS 1 "failed"))
        (#2='T
         (SEQ
          (LETT |uts|
                (SPADCALL (|ULSCONS;getUTS| |x| $) (|ULSCONS;getUTS| |y| $)
                          (QREFELT $ 115))
                . #1#)
          (EXIT
           (COND ((QEQCAR |uts| 1) (CONS 1 "failed"))
                 (#2#
                  (CONS 0
                        (SPADCALL (- (SPADCALL |x| (QREFELT $ 12)) |d|)
                                  (QCDR |uts|) (QREFELT $ 10)))))))))))))) 

(DEFUN |ULSCONS;approximate;$ICoef;43| (|x| |n| $)
  (PROG (|app| #1=#:G924 |m| |e|)
    (RETURN
     (SEQ
      (LETT |m|
            (- |n|
               (LETT |e| (|ULSCONS;getExpon| |x| $)
                     . #2=(|ULSCONS;approximate;$ICoef;43|)))
            . #2#)
      (EXIT
       (COND ((< |m| 0) (|spadConstant| $ 14))
             (#3='T
              (SEQ
               (LETT |app|
                     (SPADCALL (|ULSCONS;getUTS| |x| $)
                               (PROG1 (LETT #1# |m| . #2#)
                                 (|check-subtype| (>= #1# 0)
                                                  '(|NonNegativeInteger|) #1#))
                               (QREFELT $ 117))
                     . #2#)
               (EXIT
                (COND ((ZEROP |e|) |app|)
                      (#3#
                       (SPADCALL |app|
                                 (SPADCALL
                                  (SPADCALL
                                   (SPADCALL (SPADCALL |x| (QREFELT $ 88))
                                             (QREFELT $ 118))
                                   (SPADCALL |x| (QREFELT $ 90))
                                   (QREFELT $ 119))
                                  |e| (QREFELT $ 120))
                                 (QREFELT $ 121))))))))))))) 

(DEFUN |ULSCONS;complete;2$;44| (|x| $)
  (SPADCALL (|ULSCONS;getExpon| |x| $)
            (SPADCALL (|ULSCONS;getUTS| |x| $) (QREFELT $ 123)) (QREFELT $ 10))) 

(DEFUN |ULSCONS;extend;$I$;45| (|x| |n| $)
  (PROG (#1=#:G929 |m| |e|)
    (RETURN
     (SEQ (LETT |e| (|ULSCONS;getExpon| |x| $) . #2=(|ULSCONS;extend;$I$;45|))
          (LETT |m| (- |n| |e|) . #2#)
          (EXIT
           (COND ((< |m| 0) |x|)
                 ('T
                  (SPADCALL |e|
                            (SPADCALL (|ULSCONS;getUTS| |x| $)
                                      (PROG1 (LETT #1# |m| . #2#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))
                                      (QREFELT $ 125))
                            (QREFELT $ 10))))))))) 

(DEFUN |ULSCONS;map;M2$;46| (|f| |x| $)
  (SPADCALL (|ULSCONS;getExpon| |x| $)
            (SPADCALL |f| (|ULSCONS;getUTS| |x| $) (QREFELT $ 128))
            (QREFELT $ 10))) 

(DEFUN |ULSCONS;multiplyCoefficients;M2$;47| (|f| |x| $)
  (PROG (|e|)
    (RETURN
     (SEQ
      (LETT |e| (|ULSCONS;getExpon| |x| $)
            |ULSCONS;multiplyCoefficients;M2$;47|)
      (EXIT
       (SPADCALL |e|
                 (SPADCALL
                  (CONS #'|ULSCONS;multiplyCoefficients;M2$;47!0|
                        (VECTOR |f| $ |e|))
                  (|ULSCONS;getUTS| |x| $) (QREFELT $ 131))
                 (QREFELT $ 10))))))) 

(DEFUN |ULSCONS;multiplyCoefficients;M2$;47!0| (|z1| $$)
  (PROG (|e| $ |f|)
    (LETT |e| (QREFELT $$ 2) . #1=(|ULSCONS;multiplyCoefficients;M2$;47|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |f| (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL (SPADCALL |e| |z1| (QREFELT $ 42)) |f|))))) 

(DEFUN |ULSCONS;multiplyExponents;$Pi$;48| (|x| |n| $)
  (SPADCALL (SPADCALL |n| (|ULSCONS;getExpon| |x| $) (QREFELT $ 134))
            (SPADCALL (|ULSCONS;getUTS| |x| $) |n| (QREFELT $ 135))
            (QREFELT $ 10))) 

(DEFUN |ULSCONS;differentiate;2$;49| (|x| $)
  (PROG (|e|)
    (RETURN
     (SEQ (LETT |e| (|ULSCONS;getExpon| |x| $) |ULSCONS;differentiate;2$;49|)
          (EXIT
           (SPADCALL (- |e| 1)
                     (SPADCALL
                      (CONS #'|ULSCONS;differentiate;2$;49!0| (VECTOR $ |e|))
                      (|ULSCONS;getUTS| |x| $) (QREFELT $ 131))
                     (QREFELT $ 10))))))) 

(DEFUN |ULSCONS;differentiate;2$;49!0| (|z1| $$)
  (PROG (|e| $)
    (LETT |e| (QREFELT $$ 1) . #1=(|ULSCONS;differentiate;2$;49|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL (SPADCALL |e| |z1| (QREFELT $ 42)) (QREFELT $ 22)))))) 

(DEFUN |ULSCONS;differentiate;$S$;50| (|x| |s| $)
  (PROG ()
    (RETURN
     (COND
      ((EQUAL |s| (SPADCALL |x| (QREFELT $ 88)))
       (SPADCALL |x| (QREFELT $ 137)))
      ('T
       (SPADCALL
        (SPADCALL (CONS #'|ULSCONS;differentiate;$S$;50!0| (VECTOR $ |s|)) |x|
                  (QREFELT $ 129))
        (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 90)) |s| (QREFELT $ 138))
                  (SPADCALL |x| (QREFELT $ 137)) (QREFELT $ 139))
        (QREFELT $ 68))))))) 

(DEFUN |ULSCONS;differentiate;$S$;50!0| (|z1| $$)
  (PROG (|s| $)
    (LETT |s| (QREFELT $$ 1) . #1=(|ULSCONS;differentiate;$S$;50|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z1| |s| (QREFELT $ 138)))))) 

(DEFUN |ULSCONS;characteristic;Nni;51| ($) (SPADCALL (QREFELT $ 141))) 

(DEFUN |ULSCONS;retract;$UTS;52| (|x| $) (SPADCALL |x| (QREFELT $ 31))) 

(DEFUN |ULSCONS;retractIfCan;$U;53| (|x| $) (SPADCALL |x| (QREFELT $ 30))) 

(DEFUN |ULSCONS;^;$I$;54| (|x| |n| $)
  (PROG (|minusN| #1=#:G953 |xInv| #2=#:G952)
    (RETURN
     (SEQ
      (COND
       ((ZEROP |n|)
        (COND ((SPADCALL |x| (QREFELT $ 70)) (|error| "0 ^ 0 is undefined"))
              (#3='T (|spadConstant| $ 17))))
       ((< 0 |n|)
        (SPADCALL (* |n| (|ULSCONS;getExpon| |x| $))
                  (SPADCALL (|ULSCONS;getUTS| |x| $)
                            (PROG1 (LETT #2# |n| . #4=(|ULSCONS;^;$I$;54|))
                              (|check-subtype| (>= #2# 0)
                                               '(|NonNegativeInteger|) #2#))
                            (QREFELT $ 72))
                  (QREFELT $ 10)))
       (#3#
        (SEQ (LETT |xInv| (SPADCALL |x| (QREFELT $ 145)) . #4#)
             (LETT |minusN|
                   (PROG1 (LETT #1# (- |n|) . #4#)
                     (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                   . #4#)
             (EXIT
              (SPADCALL
               (SPADCALL |minusN| (|ULSCONS;getExpon| |xInv| $) (QREFELT $ 71))
               (SPADCALL (|ULSCONS;getUTS| |xInv| $) |minusN| (QREFELT $ 72))
               (QREFELT $ 10)))))))))) 

(DEFUN |ULSCONS;*;UTS2$;55| (|x| |y| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 20)) |y| (QREFELT $ 69))) 

(DEFUN |ULSCONS;*;$UTS$;56| (|x| |y| $)
  (SPADCALL |x| (SPADCALL |y| (QREFELT $ 20)) (QREFELT $ 69))) 

(DEFUN |ULSCONS;inv;2$;57| (|x| $)
  (PROG (|xInv|)
    (RETURN
     (SEQ (LETT |xInv| (SPADCALL |x| (QREFELT $ 77)) |ULSCONS;inv;2$;57|)
          (EXIT
           (COND
            ((QEQCAR |xInv| 1)
             (|error| "multiplicative inverse does not exist"))
            ('T (QCDR |xInv|)))))))) 

(DEFUN |ULSCONS;/;3$;58| (|x| |y| $)
  (PROG (|yInv|)
    (RETURN
     (SEQ (LETT |yInv| (SPADCALL |y| (QREFELT $ 77)) |ULSCONS;/;3$;58|)
          (EXIT
           (COND
            ((QEQCAR |yInv| 1)
             (|error| "inv: multiplicative inverse does not exist"))
            ('T (SPADCALL |x| (QCDR |yInv|) (QREFELT $ 69))))))))) 

(DEFUN |ULSCONS;/;2UTS$;59| (|x| |y| $)
  (SPADCALL (SPADCALL |x| (QREFELT $ 20)) (SPADCALL |y| (QREFELT $ 20))
            (QREFELT $ 149))) 

(DEFUN |ULSCONS;numer;$UTS;60| (|x| $)
  (PROG (|n| #1=#:G974)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |n| (SPADCALL |x| (QREFELT $ 12))
               . #2=(|ULSCONS;numer;$UTS;60|))
         (EXIT
          (COND
           ((NULL (< |n| 0))
            (PROGN (LETT #1# (SPADCALL |x| (QREFELT $ 31)) . #2#) (GO #1#))))))
        (LETT |x| (SPADCALL (- |n|) |x| (QREFELT $ 24)) . #2#)
        (LETT |n| (SPADCALL |x| (QREFELT $ 12)) . #2#)
        (EXIT
         (COND ((EQL |n| 0) (SPADCALL |x| (QREFELT $ 31)))
               ('T (|ULSCONS;getUTS| |x| $))))))
      #1# (EXIT #1#))))) 

(DEFUN |ULSCONS;denom;$UTS;61| (|x| $)
  (PROG (#1=#:G977 |n| #2=#:G978)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (SEQ
         (LETT |n| (SPADCALL |x| (QREFELT $ 12))
               . #3=(|ULSCONS;denom;$UTS;61|))
         (EXIT
          (COND
           ((NULL (< |n| 0))
            (PROGN (LETT #2# (|spadConstant| $ 16) . #3#) (GO #2#))))))
        (LETT |x| (SPADCALL (- |n|) |x| (QREFELT $ 24)) . #3#)
        (LETT |n| (SPADCALL |x| (QREFELT $ 12)) . #3#)
        (EXIT
         (COND ((EQL |n| 0) (|spadConstant| $ 16))
               ('T
                (SPADCALL (|spadConstant| $ 25)
                          (PROG1 (LETT #1# (- |n|) . #3#)
                            (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                             #1#))
                          (QREFELT $ 27)))))))
      #2# (EXIT #2#))))) 

(DEFUN |ULSCONS;coerce;F$;62| (|r| $)
  (SPADCALL (SPADCALL |r| (QREFELT $ 154)) (QREFELT $ 21))) 

(DEFUN |ULSCONS;^;$F$;63| (|x| |r| $) (SPADCALL |x| |r| (QREFELT $ 157))) 

(DEFUN |ULSCONS;exp;2$;64| (|x| $) (SPADCALL |x| (QREFELT $ 159))) 

(DEFUN |ULSCONS;log;2$;65| (|x| $) (SPADCALL |x| (QREFELT $ 161))) 

(DEFUN |ULSCONS;sin;2$;66| (|x| $) (SPADCALL |x| (QREFELT $ 163))) 

(DEFUN |ULSCONS;cos;2$;67| (|x| $) (SPADCALL |x| (QREFELT $ 165))) 

(DEFUN |ULSCONS;tan;2$;68| (|x| $) (SPADCALL |x| (QREFELT $ 167))) 

(DEFUN |ULSCONS;cot;2$;69| (|x| $) (SPADCALL |x| (QREFELT $ 169))) 

(DEFUN |ULSCONS;sec;2$;70| (|x| $) (SPADCALL |x| (QREFELT $ 171))) 

(DEFUN |ULSCONS;csc;2$;71| (|x| $) (SPADCALL |x| (QREFELT $ 173))) 

(DEFUN |ULSCONS;asin;2$;72| (|x| $) (SPADCALL |x| (QREFELT $ 175))) 

(DEFUN |ULSCONS;acos;2$;73| (|x| $) (SPADCALL |x| (QREFELT $ 177))) 

(DEFUN |ULSCONS;atan;2$;74| (|x| $) (SPADCALL |x| (QREFELT $ 179))) 

(DEFUN |ULSCONS;acot;2$;75| (|x| $) (SPADCALL |x| (QREFELT $ 181))) 

(DEFUN |ULSCONS;asec;2$;76| (|x| $) (SPADCALL |x| (QREFELT $ 183))) 

(DEFUN |ULSCONS;acsc;2$;77| (|x| $) (SPADCALL |x| (QREFELT $ 185))) 

(DEFUN |ULSCONS;sinh;2$;78| (|x| $) (SPADCALL |x| (QREFELT $ 187))) 

(DEFUN |ULSCONS;cosh;2$;79| (|x| $) (SPADCALL |x| (QREFELT $ 189))) 

(DEFUN |ULSCONS;tanh;2$;80| (|x| $) (SPADCALL |x| (QREFELT $ 191))) 

(DEFUN |ULSCONS;coth;2$;81| (|x| $) (SPADCALL |x| (QREFELT $ 193))) 

(DEFUN |ULSCONS;sech;2$;82| (|x| $) (SPADCALL |x| (QREFELT $ 195))) 

(DEFUN |ULSCONS;csch;2$;83| (|x| $) (SPADCALL |x| (QREFELT $ 197))) 

(DEFUN |ULSCONS;asinh;2$;84| (|x| $) (SPADCALL |x| (QREFELT $ 199))) 

(DEFUN |ULSCONS;acosh;2$;85| (|x| $) (SPADCALL |x| (QREFELT $ 201))) 

(DEFUN |ULSCONS;atanh;2$;86| (|x| $) (SPADCALL |x| (QREFELT $ 203))) 

(DEFUN |ULSCONS;acoth;2$;87| (|x| $) (SPADCALL |x| (QREFELT $ 205))) 

(DEFUN |ULSCONS;asech;2$;88| (|x| $) (SPADCALL |x| (QREFELT $ 207))) 

(DEFUN |ULSCONS;acsch;2$;89| (|x| $) (SPADCALL |x| (QREFELT $ 209))) 

(DEFUN |ULSCONS;ratInv| (|n| $)
  (COND ((ZEROP |n|) (|spadConstant| $ 25))
        ('T
         (SPADCALL (SPADCALL (SPADCALL |n| (QREFELT $ 211)) (QREFELT $ 212))
                   (QREFELT $ 154))))) 

(DEFUN |ULSCONS;integrate;2$;91| (|x| $)
  (PROG (|e|)
    (RETURN
     (SEQ
      (COND
       ((NULL (SPADCALL (SPADCALL |x| -1 (QREFELT $ 74)) (QREFELT $ 39)))
        (|error| "integrate: series has term of order -1"))
       ('T
        (SEQ (LETT |e| (|ULSCONS;getExpon| |x| $) |ULSCONS;integrate;2$;91|)
             (EXIT
              (SPADCALL (+ |e| 1)
                        (SPADCALL
                         (CONS #'|ULSCONS;integrate;2$;91!0| (VECTOR $ |e|))
                         (|ULSCONS;getUTS| |x| $) (QREFELT $ 131))
                        (QREFELT $ 10)))))))))) 

(DEFUN |ULSCONS;integrate;2$;91!0| (|z1| $$)
  (PROG (|e| $)
    (LETT |e| (QREFELT $$ 1) . #1=(|ULSCONS;integrate;2$;91|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (|ULSCONS;ratInv|
       (SPADCALL (SPADCALL |e| (|spadConstant| $ 41) (QREFELT $ 42)) |z1|
                 (QREFELT $ 42))
       $))))) 

(DEFUN |ULSCONS;integrate;$S$;92| (|x| |s| $)
  (PROG ()
    (RETURN
     (COND
      ((EQUAL |s| (SPADCALL |x| (QREFELT $ 88)))
       (SPADCALL |x| (QREFELT $ 214)))
      ((NULL
        (SPADCALL |s| (SPADCALL (SPADCALL |x| (QREFELT $ 90)) (QREFELT $ 216))
                  (QREFELT $ 217)))
       (SPADCALL (CONS #'|ULSCONS;integrate;$S$;92!0| (VECTOR $ |s|)) |x|
                 (QREFELT $ 129)))
      ('T
       (|error|
        "integrate: center is a function of variable of integration")))))) 

(DEFUN |ULSCONS;integrate;$S$;92!0| (|z1| $$)
  (PROG (|s| $)
    (LETT |s| (QREFELT $$ 1) . #1=(|ULSCONS;integrate;$S$;92|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (SPADCALL |z1| |s| (QREFELT $ 218)))))) 

(DEFUN |ULSCONS;integrateWithOneAnswer| (|f| |s| $)
  (PROG (|res|)
    (RETURN
     (SEQ
      (LETT |res| (SPADCALL |f| |s| (QREFELT $ 222))
            |ULSCONS;integrateWithOneAnswer|)
      (EXIT
       (COND ((QEQCAR |res| 0) (QCDR |res|))
             ('T (|SPADfirst| (QCDR |res|))))))))) 

(DEFUN |ULSCONS;integrate;$S$;94| (|x| |s| $)
  (PROG ()
    (RETURN
     (COND
      ((EQUAL |s| (SPADCALL |x| (QREFELT $ 88)))
       (SPADCALL |x| (QREFELT $ 214)))
      ((NULL
        (SPADCALL |s| (SPADCALL (SPADCALL |x| (QREFELT $ 90)) (QREFELT $ 216))
                  (QREFELT $ 217)))
       (SPADCALL (CONS #'|ULSCONS;integrate;$S$;94!0| (VECTOR $ |s|)) |x|
                 (QREFELT $ 129)))
      ('T
       (|error|
        "integrate: center is a function of variable of integration")))))) 

(DEFUN |ULSCONS;integrate;$S$;94!0| (|z1| $$)
  (PROG (|s| $)
    (LETT |s| (QREFELT $$ 1) . #1=(|ULSCONS;integrate;$S$;94|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN (PROGN (|ULSCONS;integrateWithOneAnswer| |z1| |s| $))))) 

(DEFUN |ULSCONS;termOutput| (|k| |c| |vv| $)
  (PROG (|mon|)
    (RETURN
     (SEQ
      (COND ((EQL |k| 0) (SPADCALL |c| (QREFELT $ 224)))
            (#1='T
             (SEQ
              (LETT |mon|
                    (COND ((EQL |k| 1) |vv|)
                          (#1#
                           (SPADCALL |vv| (SPADCALL |k| (QREFELT $ 225))
                                     (QREFELT $ 226))))
                    |ULSCONS;termOutput|)
              (EXIT
               (COND
                ((SPADCALL |c| (|spadConstant| $ 25) (QREFELT $ 59)) |mon|)
                ((SPADCALL |c| (SPADCALL (|spadConstant| $ 25) (QREFELT $ 227))
                           (QREFELT $ 59))
                 (SPADCALL |mon| (QREFELT $ 228)))
                (#1#
                 (SPADCALL (SPADCALL |c| (QREFELT $ 224)) |mon|
                           (QREFELT $ 229)))))))))))) 

(PUT '|ULSCONS;showAll?| '|SPADreplace| '(XLAM NIL 'T)) 

(DEFUN |ULSCONS;showAll?| ($) 'T) 

(DEFUN |ULSCONS;termsToOutputForm| (|m| |uu| |xxx| $)
  (PROG (|l| |n| |count|)
    (RETURN
     (SEQ (LETT |l| NIL . #1=(|ULSCONS;termsToOutputForm|))
          (EXIT
           (COND
            ((SPADCALL |uu| (QREFELT $ 34))
             (SPADCALL (|spadConstant| $ 14) (QREFELT $ 224)))
            (#2='T
             (SEQ (LETT |count| |$streamCount| . #1#)
                  (SEQ (LETT |n| 0 . #1#) G190
                       (COND
                        ((OR (QSGREATERP |n| |count|)
                             (NULL
                              (COND ((SPADCALL |uu| (QREFELT $ 34)) 'NIL)
                                    ('T 'T))))
                         #3=(GO G191)))
                       (SEQ
                        (COND
                         ((NULL
                           (SPADCALL (SPADCALL |uu| (QREFELT $ 38))
                                     (|spadConstant| $ 14) (QREFELT $ 59)))
                          (LETT |l|
                                (CONS
                                 (|ULSCONS;termOutput| (+ |n| |m|)
                                  (SPADCALL |uu| (QREFELT $ 38)) |xxx| $)
                                 |l|)
                                . #1#)))
                        (EXIT
                         (LETT |uu| (SPADCALL |uu| (QREFELT $ 40)) . #1#)))
                       (LETT |n| (QSADD1 |n|) . #1#) #4=(GO G190) G191
                       (EXIT NIL))
                  (COND
                   ((|ULSCONS;showAll?| $)
                    (SEQ (LETT |n| (+ |count| 1) . #1#) G190
                         (COND
                          ((NULL
                            (COND
                             ((SPADCALL |uu| (QREFELT $ 230))
                              (COND
                               ((SPADCALL |uu| (SPADCALL |uu| (QREFELT $ 40))
                                          (QREFELT $ 231))
                                'NIL)
                               ('T 'T)))
                             ('T 'NIL)))
                           #3#))
                         (SEQ
                          (COND
                           ((NULL
                             (SPADCALL (SPADCALL |uu| (QREFELT $ 38))
                                       (|spadConstant| $ 14) (QREFELT $ 59)))
                            (LETT |l|
                                  (CONS
                                   (|ULSCONS;termOutput| (+ |n| |m|)
                                    (SPADCALL |uu| (QREFELT $ 38)) |xxx| $)
                                   |l|)
                                  . #1#)))
                          (EXIT
                           (LETT |uu| (SPADCALL |uu| (QREFELT $ 40)) . #1#)))
                         (LETT |n| (+ |n| 1) . #1#) #4# G191 (EXIT NIL))))
                  (LETT |l|
                        (COND ((SPADCALL |uu| (QREFELT $ 232)) |l|)
                              (#2#
                               (SEQ
                                (COND
                                 ((SPADCALL |uu| (SPADCALL |uu| (QREFELT $ 40))
                                            (QREFELT $ 231))
                                  (COND
                                   ((SPADCALL (SPADCALL |uu| (QREFELT $ 38))
                                              (|spadConstant| $ 14)
                                              (QREFELT $ 59))
                                    (EXIT |l|)))))
                                (EXIT
                                 (CONS
                                  (SPADCALL "O"
                                            (LIST
                                             (SPADCALL |xxx|
                                                       (SPADCALL (+ |n| |m|)
                                                                 (QREFELT $
                                                                          225))
                                                       (QREFELT $ 226)))
                                            (QREFELT $ 234))
                                  |l|)))))
                        . #1#)
                  (EXIT
                   (COND
                    ((NULL |l|)
                     (SPADCALL (|spadConstant| $ 14) (QREFELT $ 224)))
                    (#2#
                     (SPADCALL (ELT $ 235) (NREVERSE |l|)
                               (QREFELT $ 238))))))))))))) 

(DEFUN |ULSCONS;coerce;$Of;98| (|x| $)
  (PROG (|xxx| |cen| |var| |p| |uts| |m|)
    (RETURN
     (SEQ
      (LETT |x| (SPADCALL |$streamCount| |x| (QREFELT $ 24))
            . #1=(|ULSCONS;coerce;$Of;98|))
      (LETT |m| (SPADCALL |x| (QREFELT $ 12)) . #1#)
      (LETT |uts| (|ULSCONS;getUTS| |x| $) . #1#)
      (LETT |p| (SPADCALL |uts| (QREFELT $ 46)) . #1#)
      (LETT |var| (SPADCALL |uts| (QREFELT $ 87)) . #1#)
      (LETT |cen| (SPADCALL |uts| (QREFELT $ 89)) . #1#)
      (LETT |xxx|
            (COND
             ((SPADCALL |cen| (QREFELT $ 39)) (SPADCALL |var| (QREFELT $ 239)))
             ('T
              (SPADCALL
               (SPADCALL (SPADCALL |var| (QREFELT $ 239))
                         (SPADCALL |cen| (QREFELT $ 224)) (QREFELT $ 240))
               (QREFELT $ 241))))
            . #1#)
      (EXIT (|ULSCONS;termsToOutputForm| |m| |p| |xxx| $)))))) 

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

(DEFUN |UnivariateLaurentSeriesConstructor;| (|#1| |#2|)
  (PROG (|pv$| #1=#:G1088 #2=#:G1089 #3=#:G1090 #4=#:G1091 #5=#:G1093 $ |dv$|
         DV$2 DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|)
            . #6=(|UnivariateLaurentSeriesConstructor|))
      (LETT DV$2 (|devaluate| |#2|) . #6#)
      (LETT |dv$| (LIST '|UnivariateLaurentSeriesConstructor| DV$1 DV$2) . #6#)
      (LETT $ (GETREFV 282) . #6#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3
                (LETT |pv$|
                      (|buildPredVector| 0 0
                                         (LIST
                                          (|HasCategory| |#1|
                                                         '(|CommutativeRing|))
                                          (|HasCategory| |#1|
                                                         '(|IntegralDomain|))
                                          (OR
                                           (|HasCategory| |#1|
                                                          '(|CommutativeRing|))
                                           (|HasCategory| |#1|
                                                          '(|IntegralDomain|)))
                                          (|HasCategory| (|Integer|)
                                                         '(|SemiGroup|))
                                          (LETT #5#
                                                (|HasCategory| |#1| '(|Field|))
                                                . #6#)
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|CharacteristicZero|)))
                                           (|HasCategory| |#1|
                                                          '(|CharacteristicZero|)))
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|PartialDifferentialRing|
                                                                 (|Symbol|))))
                                           (AND
                                            (|HasCategory| |#1|
                                                           '(|PartialDifferentialRing|
                                                             (|Symbol|)))
                                            (|HasSignature| |#1|
                                                            (LIST '*
                                                                  (LIST
                                                                   (|devaluate|
                                                                    |#1|)
                                                                   '(|Integer|)
                                                                   (|devaluate|
                                                                    |#1|))))))
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|DifferentialRing|)))
                                           (|HasSignature| |#1|
                                                           (LIST '*
                                                                 (LIST
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  '(|Integer|)
                                                                  (|devaluate|
                                                                   |#1|)))))
                                          (OR #5#
                                              (|HasCategory| |#1|
                                                             '(|IntegralDomain|)))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|RetractableTo|
                                                                (|Symbol|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|ConvertibleTo|
                                                                (|InputForm|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|RealConstant|)))
                                          (OR
                                           (|HasCategory| |#1|
                                                          '(|CommutativeRing|))
                                           #5#
                                           (|HasCategory| |#1|
                                                          '(|IntegralDomain|)))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|OrderedIntegralDomain|)))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|RetractableTo|
                                                                (|Integer|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|StepThrough|)))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              (LIST '|Eltable|
                                                                    (|devaluate|
                                                                     |#2|)
                                                                    (|devaluate|
                                                                     |#2|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              (LIST '|Evalable|
                                                                    (|devaluate|
                                                                     |#2|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              (LIST
                                                               '|InnerEvalable|
                                                               '(|Symbol|)
                                                               (|devaluate|
                                                                |#2|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|LinearlyExplicitRingOver|
                                                                (|Integer|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|ConvertibleTo|
                                                                (|Pattern|
                                                                 (|Integer|)))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|ConvertibleTo|
                                                                (|Pattern|
                                                                 (|Float|)))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|PatternMatchable|
                                                                (|Integer|))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|PatternMatchable|
                                                                (|Float|))))
                                          (|HasSignature| |#1|
                                                          (LIST '^
                                                                (LIST
                                                                 (|devaluate|
                                                                  |#1|)
                                                                 (|devaluate|
                                                                  |#1|)
                                                                 '(|Integer|))))
                                          (AND
                                           (|HasSignature| |#1|
                                                           (LIST '^
                                                                 (LIST
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  '(|Integer|))))
                                           (|HasSignature| |#1|
                                                           (LIST '|coerce|
                                                                 (LIST
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  '(|Symbol|)))))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|Comparable|)))
                                          (LETT #4#
                                                (AND
                                                 (|HasCategory| |#1|
                                                                '(|Field|))
                                                 (|HasCategory| |#2|
                                                                '(|OrderedSet|)))
                                                . #6#)
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|OrderedIntegralDomain|)))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|Comparable|)))
                                           #4#)
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|OrderedIntegralDomain|)))
                                           #4#)
                                          (LETT #3#
                                                (|HasCategory| |#2|
                                                               '(|PolynomialFactorizationExplicit|))
                                                . #6#)
                                          (AND #5# #3#)
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|IntegerNumberSystem|)))
                                          (AND #5#
                                               (|HasCategory| |#2|
                                                              '(|EuclideanDomain|)))
                                          (|HasCategory| |#2|
                                                         '(|CharacteristicNonZero|))
                                          (LETT #2#
                                                (|HasCategory| |#1|
                                                               '(|CharacteristicNonZero|))
                                                . #6#)
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|CharacteristicNonZero|)))
                                           #2#)
                                          (LETT #1#
                                                (|HasCategory| |#1|
                                                               '(|Algebra|
                                                                 (|Fraction|
                                                                  (|Integer|))))
                                                . #6#)
                                          (OR
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|OrderedIntegralDomain|)))
                                           (AND #5# #3#)
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|ConvertibleTo|
                                                                 (|InputForm|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               (LIST '|Eltable|
                                                                     (|devaluate|
                                                                      |#2|)
                                                                     (|devaluate|
                                                                      |#2|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|Evalable|
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               (LIST
                                                                '|InnerEvalable|
                                                                '(|Symbol|)
                                                                (|devaluate|
                                                                 |#2|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Integer|))))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|RetractableTo|
                                                                 (|Symbol|))))
                                           #4#
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|RealConstant|)))
                                           (AND #5#
                                                (|HasCategory| |#2|
                                                               '(|StepThrough|)))
                                           #1#)
                                          (OR
                                           (AND
                                            (|HasCategory| |#1|
                                                           '(|PrimitiveFunctionCategory|))
                                            (|HasCategory| |#1|
                                                           '(|TranscendentalFunctionCategory|))
                                            (|HasCategory| |#1|
                                                           '(|AlgebraicallyClosedFunctionSpace|
                                                             (|Integer|)))
                                            #1#)
                                           (AND #1#
                                                (|HasSignature| |#1|
                                                                (LIST
                                                                 '|integrate|
                                                                 (LIST
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  (|devaluate|
                                                                   |#1|)
                                                                  '(|Symbol|))))
                                                (|HasSignature| |#1|
                                                                (LIST
                                                                 '|variables|
                                                                 (LIST
                                                                  '(|List|
                                                                    (|Symbol|))
                                                                  (|devaluate|
                                                                   |#1|))))))))
                      . #6#))
      (|haddProp| |$ConstructorCache| '|UnivariateLaurentSeriesConstructor|
                  (LIST DV$1 DV$2) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7 |#2|)
      (AND (|HasCategory| $ '(|CharacteristicNonZero|)) #5# #3#
           (|augmentPredVector| $ 1099511627776))
      (AND
       (OR (AND (|HasCategory| $ '(|CharacteristicNonZero|)) #5# #3#)
           (AND #5# (|HasCategory| |#2| '(|CharacteristicNonZero|))) #2#)
       (|augmentPredVector| $ 2199023255552))
      (QSETREFV $ 8 (|Record| (|:| |expon| (|Integer|)) (|:| |ps| |#2|)))
      (COND
       ((|testBitVector| |pv$| 2)
        (PROGN
         (QSETREFV $ 112
                   (CONS (|dispatchFunction| |ULSCONS;rationalFunction;$IF;40|)
                         $))
         (QSETREFV $ 114
                   (CONS
                    (|dispatchFunction| |ULSCONS;rationalFunction;$2IF;41|) $))
         (QSETREFV $ 116
                   (CONS (|dispatchFunction| |ULSCONS;exquo;2$U;42|) $)))))
      (COND
       ((|HasSignature| |#1|
                        (LIST '|coerce| (LIST (|devaluate| |#1|) '(|Symbol|))))
        (COND
         ((|testBitVector| |pv$| 25)
          (QSETREFV $ 122
                    (CONS (|dispatchFunction| |ULSCONS;approximate;$ICoef;43|)
                          $))))))
      (COND
       ((|HasCategory| |#1| '(|PartialDifferentialRing| (|Symbol|)))
        (QSETREFV $ 140
                  (CONS (|dispatchFunction| |ULSCONS;differentiate;$S$;50|)
                        $))))
      (COND
       ((|testBitVector| |pv$| 5)
        (PROGN
         (QSETREFV $ 143
                   (CONS (|dispatchFunction| |ULSCONS;retract;$UTS;52|) $))
         (QSETREFV $ 144
                   (CONS (|dispatchFunction| |ULSCONS;retractIfCan;$U;53|) $))
         (QSETREFV $ 146 (CONS (|dispatchFunction| |ULSCONS;^;$I$;54|) $))
         (QSETREFV $ 147 (CONS (|dispatchFunction| |ULSCONS;*;UTS2$;55|) $))
         (QSETREFV $ 148 (CONS (|dispatchFunction| |ULSCONS;*;$UTS$;56|) $))
         (QSETREFV $ 145 (CONS (|dispatchFunction| |ULSCONS;inv;2$;57|) $))
         (QSETREFV $ 149 (CONS (|dispatchFunction| |ULSCONS;/;3$;58|) $))
         (QSETREFV $ 150 (CONS (|dispatchFunction| |ULSCONS;/;2UTS$;59|) $))
         (QSETREFV $ 151 (CONS (|dispatchFunction| |ULSCONS;numer;$UTS;60|) $))
         (QSETREFV $ 152
                   (CONS (|dispatchFunction| |ULSCONS;denom;$UTS;61|) $)))))
      (COND
       ((|testBitVector| |pv$| 38)
        (PROGN
         (QSETREFV $ 155 (CONS (|dispatchFunction| |ULSCONS;coerce;F$;62|) $))
         (COND
          ((|testBitVector| |pv$| 5)
           (QSETREFV $ 158 (CONS (|dispatchFunction| |ULSCONS;^;$F$;63|) $))))
         (QSETREFV $ 160 (CONS (|dispatchFunction| |ULSCONS;exp;2$;64|) $))
         (QSETREFV $ 162 (CONS (|dispatchFunction| |ULSCONS;log;2$;65|) $))
         (QSETREFV $ 164 (CONS (|dispatchFunction| |ULSCONS;sin;2$;66|) $))
         (QSETREFV $ 166 (CONS (|dispatchFunction| |ULSCONS;cos;2$;67|) $))
         (QSETREFV $ 168 (CONS (|dispatchFunction| |ULSCONS;tan;2$;68|) $))
         (QSETREFV $ 170 (CONS (|dispatchFunction| |ULSCONS;cot;2$;69|) $))
         (QSETREFV $ 172 (CONS (|dispatchFunction| |ULSCONS;sec;2$;70|) $))
         (QSETREFV $ 174 (CONS (|dispatchFunction| |ULSCONS;csc;2$;71|) $))
         (QSETREFV $ 176 (CONS (|dispatchFunction| |ULSCONS;asin;2$;72|) $))
         (QSETREFV $ 178 (CONS (|dispatchFunction| |ULSCONS;acos;2$;73|) $))
         (QSETREFV $ 180 (CONS (|dispatchFunction| |ULSCONS;atan;2$;74|) $))
         (QSETREFV $ 182 (CONS (|dispatchFunction| |ULSCONS;acot;2$;75|) $))
         (QSETREFV $ 184 (CONS (|dispatchFunction| |ULSCONS;asec;2$;76|) $))
         (QSETREFV $ 186 (CONS (|dispatchFunction| |ULSCONS;acsc;2$;77|) $))
         (QSETREFV $ 188 (CONS (|dispatchFunction| |ULSCONS;sinh;2$;78|) $))
         (QSETREFV $ 190 (CONS (|dispatchFunction| |ULSCONS;cosh;2$;79|) $))
         (QSETREFV $ 192 (CONS (|dispatchFunction| |ULSCONS;tanh;2$;80|) $))
         (QSETREFV $ 194 (CONS (|dispatchFunction| |ULSCONS;coth;2$;81|) $))
         (QSETREFV $ 196 (CONS (|dispatchFunction| |ULSCONS;sech;2$;82|) $))
         (QSETREFV $ 198 (CONS (|dispatchFunction| |ULSCONS;csch;2$;83|) $))
         (QSETREFV $ 200 (CONS (|dispatchFunction| |ULSCONS;asinh;2$;84|) $))
         (QSETREFV $ 202 (CONS (|dispatchFunction| |ULSCONS;acosh;2$;85|) $))
         (QSETREFV $ 204 (CONS (|dispatchFunction| |ULSCONS;atanh;2$;86|) $))
         (QSETREFV $ 206 (CONS (|dispatchFunction| |ULSCONS;acoth;2$;87|) $))
         (QSETREFV $ 208 (CONS (|dispatchFunction| |ULSCONS;asech;2$;88|) $))
         (QSETREFV $ 210 (CONS (|dispatchFunction| |ULSCONS;acsch;2$;89|) $))
         NIL
         (QSETREFV $ 214
                   (CONS (|dispatchFunction| |ULSCONS;integrate;2$;91|) $))
         (COND
          ((|HasSignature| |#1|
                           (LIST '|integrate|
                                 (LIST (|devaluate| |#1|) (|devaluate| |#1|)
                                       '(|Symbol|))))
           (COND
            ((|HasSignature| |#1|
                             (LIST '|variables|
                                   (LIST '(|List| (|Symbol|))
                                         (|devaluate| |#1|))))
             (QSETREFV $ 219
                       (CONS (|dispatchFunction| |ULSCONS;integrate;$S$;92|)
                             $))))))
         (COND
          ((|HasCategory| |#1| '(|TranscendentalFunctionCategory|))
           (COND
            ((|HasCategory| |#1| '(|PrimitiveFunctionCategory|))
             (COND
              ((|HasCategory| |#1|
                              '(|AlgebraicallyClosedFunctionSpace|
                                (|Integer|)))
               (PROGN
                (QSETREFV $ 219
                          (CONS (|dispatchFunction| |ULSCONS;integrate;$S$;94|)
                                $))))))))))))
      $)))) 

(MAKEPROP '|UnivariateLaurentSeriesConstructor| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|) '|Rep|
              (|Integer|) |ULSCONS;laurent;IUTS$;3| |ULSCONS;taylorRep;$UTS;4|
              |ULSCONS;degree;$I;5|
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |ULSCONS;Zero;$;6|) $))
              (0 . |Zero|) (4 . |Zero|) (8 . |One|)
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |ULSCONS;One;$;7|) $))
              (12 . |coerce|) |ULSCONS;monomial;CoefI$;8|
              |ULSCONS;coerce;UTS$;9| |ULSCONS;coerce;Coef$;10| (17 . |coerce|)
              |ULSCONS;coerce;I$;11| |ULSCONS;removeZeroes;I2$;22| (22 . |One|)
              (|NonNegativeInteger|) (26 . |monomial|) (32 . *)
              (|Union| 7 '"failed") |ULSCONS;taylorIfCan;$U;12|
              |ULSCONS;taylor;$UTS;13| (|Boolean|) (|Stream| 6) (38 . |empty?|)
              (|Record| (|:| |k| 9) (|:| |c| 6)) (|Stream| 35) (43 . |empty|)
              (47 . |frst|) (52 . |zero?|) (57 . |rst|) (62 . |One|) (66 . +)
              (72 . |concat|) (|Mapping| $) (78 . |delay|)
              (83 . |coefficients|) |ULSCONS;terms;$S;18| (88 . |empty?|)
              (93 . |empty|) (97 . |frst|) (102 . =) (108 . |rst|)
              (113 . |concat|) (119 . |Zero|) (123 . |delay|) (128 . |series|)
              |ULSCONS;series;S$;20| (133 . |coefficient|) (139 . =)
              (145 . |quoByVar|) |ULSCONS;removeZeroes;2$;21| (150 . =)
              |ULSCONS;=;2$B;23| |ULSCONS;pole?;$B;24| (156 . +)
              |ULSCONS;+;3$;25| (162 . -) |ULSCONS;-;3$;26| |ULSCONS;*;3$;27|
              (168 . |zero?|) (173 . *) (179 . ^) |ULSCONS;^;$Nni$;28|
              |ULSCONS;coefficient;$ICoef;34| (|Union| $ '"failed")
              (185 . |recip|) |ULSCONS;recip;$U;29| (190 . |elt|)
              |ULSCONS;elt;3$;30| (196 . |recip|) (201 . ^) (207 . |eval|)
              (|StreamTaylorSeriesOperations| 6) (213 . *)
              |ULSCONS;eval;$CoefS;31| (|Symbol|) (219 . |variable|)
              |ULSCONS;variable;$S;32| (224 . |center|)
              |ULSCONS;center;$Coef;33| |ULSCONS;elt;$ICoef;35| (229 . |order|)
              |ULSCONS;order;$I;36| (234 . |order|) |ULSCONS;order;$2I;37|
              (240 . |truncate|) |ULSCONS;truncate;$I$;38| (246 . |truncate|)
              |ULSCONS;truncate;$2I$;39| (|Fraction| 102) (253 . |Zero|)
              (|Polynomial| 6) (257 . |polynomial|) (263 . |coerce|)
              (268 . |coerce|) (273 . |coerce|) (278 . |positive?|) (283 . -)
              (289 . ^) (295 . *) (301 . /) (307 . |rationalFunction|)
              (313 . |polynomial|) (320 . |rationalFunction|) (327 . |exquo|)
              (333 . |exquo|) (339 . |approximate|) (345 . |coerce|) (350 . -)
              (356 . ^) (362 . *) (368 . |approximate|) (374 . |complete|)
              |ULSCONS;complete;2$;44| (379 . |extend|) |ULSCONS;extend;$I$;45|
              (|Mapping| 6 6) (385 . |map|) |ULSCONS;map;M2$;46|
              (|Mapping| 6 9) (391 . |multiplyCoefficients|)
              |ULSCONS;multiplyCoefficients;M2$;47| (|PositiveInteger|)
              (397 . *) (403 . |multiplyExponents|)
              |ULSCONS;multiplyExponents;$Pi$;48| |ULSCONS;differentiate;2$;49|
              (409 . |differentiate|) (415 . *) (421 . |differentiate|)
              (427 . |characteristic|) |ULSCONS;characteristic;Nni;51|
              (431 . |retract|) (436 . |retractIfCan|) (441 . |inv|) (446 . ^)
              (452 . *) (458 . *) (464 . /) (470 . /) (476 . |numer|)
              (481 . |denom|) (|Fraction| 9) (486 . |coerce|) (491 . |coerce|)
              (|ElementaryFunctionsUnivariateLaurentSeries| 6 7 $$) (496 . ^)
              (502 . ^) (508 . |exp|) (513 . |exp|) (518 . |log|) (523 . |log|)
              (528 . |sin|) (533 . |sin|) (538 . |cos|) (543 . |cos|)
              (548 . |tan|) (553 . |tan|) (558 . |cot|) (563 . |cot|)
              (568 . |sec|) (573 . |sec|) (578 . |csc|) (583 . |csc|)
              (588 . |asin|) (593 . |asin|) (598 . |acos|) (603 . |acos|)
              (608 . |atan|) (613 . |atan|) (618 . |acot|) (623 . |acot|)
              (628 . |asec|) (633 . |asec|) (638 . |acsc|) (643 . |acsc|)
              (648 . |sinh|) (653 . |sinh|) (658 . |cosh|) (663 . |cosh|)
              (668 . |tanh|) (673 . |tanh|) (678 . |coth|) (683 . |coth|)
              (688 . |sech|) (693 . |sech|) (698 . |csch|) (703 . |csch|)
              (708 . |asinh|) (713 . |asinh|) (718 . |acosh|) (723 . |acosh|)
              (728 . |atanh|) (733 . |atanh|) (738 . |acoth|) (743 . |acoth|)
              (748 . |asech|) (753 . |asech|) (758 . |acsch|) (763 . |acsch|)
              (768 . |coerce|) (773 . |inv|) (778 . -) (783 . |integrate|)
              (|List| 86) (788 . |variables|) (793 . |entry?|)
              (799 . |integrate|) (805 . |integrate|) (|Union| 6 (|List| 6))
              (|FunctionSpaceIntegration| 9 6) (811 . |integrate|)
              (|OutputForm|) (817 . |coerce|) (822 . |coerce|) (827 . ^)
              (833 . -) (838 . -) (843 . *) (849 . |explicitEntries?|)
              (854 . |eq?|) (860 . |explicitlyEmpty?|) (|List| $)
              (865 . |prefix|) (871 . +) (|Mapping| 223 223 223) (|List| 223)
              (877 . |reduce|) (883 . |coerce|) (888 . -) (894 . |paren|)
              |ULSCONS;coerce;$Of;98| (|Union| 253 '#1="failed") (|Matrix| $)
              (|InputForm|) (|Pattern| 261) (|Pattern| 9) (|List| 7)
              (|Equation| 7) (|List| 249) (|Matrix| 9)
              (|Record| (|:| |mat| 251) (|:| |vec| (|Vector| 9))) (|Vector| $)
              (|PatternMatchResult| 261 $) (|PatternMatchResult| 9 $)
              (|Union| 257 '#1#) (|List| 258) (|SparseUnivariatePolynomial| $)
              (|Factored| 258) (|DoubleFloat|) (|Float|)
              (|Union| 153 '#2="failed") (|Union| 9 '#2#) (|Union| 86 '#2#)
              (|List| 26) (|Mapping| 7 7) (|Matrix| 7)
              (|Record| (|:| |mat| 267) (|:| |vec| (|Vector| 7)))
              (|Union| 233 '"failed")
              (|Record| (|:| |coef| 233) (|:| |generator| $))
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $))
              (|Record| (|:| |coef1| $) (|:| |coef2| $))
              (|Union| 273 '"failed") (|Factored| $)
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (|List| 279) (|List| 9) (|SingletonAsOrderedSet|) (|String|)
              (|SingleInteger|))
           '#(~= 899 |zero?| 905 |wholePart| 910 |variables| 915 |variable| 920
              |unitNormal| 925 |unitCanonical| 930 |unit?| 935 |truncate| 940
              |terms| 953 |taylorRep| 958 |taylorIfCan| 963 |taylor| 968 |tanh|
              973 |tan| 978 |subtractIfCan| 983 |squareFreePolynomial| 989
              |squareFreePart| 994 |squareFree| 999 |sqrt| 1004
              |solveLinearPolynomialEquation| 1009 |smaller?| 1015 |sizeLess?|
              1021 |sinh| 1027 |sin| 1032 |sign| 1037 |series| 1042 |sech| 1047
              |sec| 1052 |sample| 1057 |retractIfCan| 1061 |retract| 1081
              |removeZeroes| 1101 |rem| 1112 |reductum| 1118 |reducedSystem|
              1123 |recip| 1145 |rationalFunction| 1150 |random| 1163 |quo|
              1167 |principalIdeal| 1173 |prime?| 1178 |positive?| 1183 |pole?|
              1188 |pi| 1193 |patternMatch| 1197 |order| 1211 |one?| 1222
              |numerator| 1227 |numer| 1232 |nthRoot| 1237 |nextItem| 1243
              |negative?| 1248 |multiplyExponents| 1253 |multiplyCoefficients|
              1259 |multiEuclidean| 1265 |monomial?| 1271 |monomial| 1276 |min|
              1296 |max| 1302 |map| 1308 |log| 1320 |leadingMonomial| 1325
              |leadingCoefficient| 1330 |lcm| 1335 |laurent| 1346 |latex| 1352
              |inv| 1357 |integrate| 1362 |init| 1373 |hash| 1377
              |gcdPolynomial| 1382 |gcd| 1388 |fractionPart| 1399 |floor| 1404
              |factorSquareFreePolynomial| 1409 |factorPolynomial| 1414
              |factor| 1419 |extendedEuclidean| 1424 |extend| 1437 |exquo| 1443
              |expressIdealMember| 1449 |exp| 1455 |eval| 1460 |euclideanSize|
              1506 |elt| 1511 |divide| 1529 |differentiate| 1535 |denominator|
              1585 |denom| 1590 |degree| 1595 |csch| 1600 |csc| 1605 |coth|
              1610 |cot| 1615 |cosh| 1620 |cos| 1625 |convert| 1630
              |conditionP| 1655 |complete| 1660 |coerce| 1665 |coefficient|
              1700 |charthRoot| 1706 |characteristic| 1711 |center| 1715
              |ceiling| 1720 |atanh| 1725 |atan| 1730 |associates?| 1735
              |asinh| 1741 |asin| 1746 |asech| 1751 |asec| 1756 |approximate|
              1761 |acsch| 1767 |acsc| 1772 |acoth| 1777 |acot| 1782 |acosh|
              1787 |acos| 1792 |abs| 1797 ^ 1802 |Zero| 1832 |One| 1836 D 1840
              >= 1890 > 1896 = 1902 <= 1908 < 1914 / 1920 - 1938 + 1949 * 1955)
           'NIL
           (CONS
            (|makeByteWordVec2| 39
                                '(0 0 5 5 0 5 32 0 5 5 0 5 14 5 9 39 2 1 5 5 5
                                  39 2 37 6 1 7 8 9 13 14 5 20 5 0 0 39 3 14 5
                                  0 0 0 0 39 39 1 14 5 5 0 14 0 0 14 0 0 0 30 5
                                  0 0 29 16 5 23 24 0 39 12 18 5 0 0 0 0 1 2 4
                                  5 5 39 39 39 39 39 39 10 11 12 12 15 15 17 18
                                  19 21 22 5))
            (CONS
             '#(|UnivariateLaurentSeriesConstructorCategory&| NIL
                |QuotientFieldCategory&| |Field&|
                |UnivariatePowerSeriesCategory&| |EuclideanDomain&|
                |PolynomialFactorizationExplicit&| |PowerSeriesCategory&| NIL
                |UniqueFactorizationDomain&| |AbelianMonoidRing&| |GcdDomain&|
                NIL |DivisionRing&| |IntegralDomain&| |Algebra&| |Algebra&|
                |Algebra&| |Algebra&| |DifferentialExtension&|
                |FullyLinearlyExplicitRingOver&| |Module&| |Module&| NIL NIL
                |Module&| |PartialDifferentialRing&| |DifferentialRing&| NIL
                NIL |OrderedRing&| |Module&| NIL NIL |Ring&| NIL NIL NIL NIL
                NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL |AbelianGroup&| NIL
                NIL NIL NIL |AbelianMonoid&| |Monoid&| NIL |OrderedSet&| NIL
                |SemiGroup&| |AbelianSemiGroup&| NIL NIL |FullyEvalableOver&|
                NIL NIL |SetCategory&| |TranscendentalFunctionCategory&| NIL
                |Evalable&| NIL |RetractableTo&| NIL |BasicType&| NIL NIL NIL
                NIL NIL NIL |TrigonometricFunctionCategory&|
                |ArcTrigonometricFunctionCategory&|
                |HyperbolicFunctionCategory&| NIL |ElementaryFunctionCategory&|
                |RadicalCategory&| |RetractableTo&| NIL NIL NIL
                |RetractableTo&| |RetractableTo&| NIL |InnerEvalable&|
                |InnerEvalable&| NIL NIL NIL)
             (CONS
              '#((|UnivariateLaurentSeriesConstructorCategory| 6 7)
                 (|UnivariateLaurentSeriesCategory| 6)
                 (|QuotientFieldCategory| 7) (|Field|)
                 (|UnivariatePowerSeriesCategory| 6 9) (|EuclideanDomain|)
                 (|PolynomialFactorizationExplicit|)
                 (|PowerSeriesCategory| 6 9 279) (|PrincipalIdealDomain|)
                 (|UniqueFactorizationDomain|) (|AbelianMonoidRing| 6 9)
                 (|GcdDomain|) (|OrderedIntegralDomain|) (|DivisionRing|)
                 (|IntegralDomain|) (|Algebra| 153) (|Algebra| $$)
                 (|Algebra| 6) (|Algebra| 7) (|DifferentialExtension| 7)
                 (|FullyLinearlyExplicitRingOver| 7) (|Module| 153)
                 (|Module| $$) (|CharacteristicNonZero|) (|CharacteristicZero|)
                 (|Module| 6) (|PartialDifferentialRing| 86)
                 (|DifferentialRing|) (|EntireRing|) (|CommutativeRing|)
                 (|OrderedRing|) (|Module| 7) (|LinearlyExplicitRingOver| 9)
                 (|LinearlyExplicitRingOver| 7) (|Ring|) (|BiModule| 6 6)
                 (|BiModule| 153 153) (|BiModule| $$ $$)
                 (|OrderedAbelianGroup|) (|BiModule| 7 7) (|Rng|)
                 (|LeftModule| 6) (|RightModule| 6) (|LeftModule| $$)
                 (|LeftModule| 153) (|RightModule| 153) (|RightModule| $$)
                 (|OrderedCancellationAbelianMonoid|) (|LeftModule| 7)
                 (|RightModule| 7) (|AbelianGroup|) (|OrderedAbelianMonoid|)
                 (|CancellationAbelianMonoid|) (|SemiRing|)
                 (|OrderedAbelianSemiGroup|) (|AbelianMonoid|) (|Monoid|)
                 (|SemiRng|) (|OrderedSet|) (|FullyPatternMatchable| 7)
                 (|SemiGroup|) (|AbelianSemiGroup|) (|Comparable|)
                 (|StepThrough|) (|FullyEvalableOver| 7) (|PatternMatchable| 9)
                 (|PatternMatchable| 261) (|SetCategory|)
                 (|TranscendentalFunctionCategory|) (|RealConstant|)
                 (|Evalable| 7) (|Patternable| 7) (|RetractableTo| 7)
                 (|unitsKnown|) (|BasicType|) (|CoercibleTo| 223)
                 (|CommutativeStar|) (|noZeroDivisors|) (|Eltable| $$ $$)
                 (|canonicalUnitNormal|) (|canonicalsClosed|)
                 (|TrigonometricFunctionCategory|)
                 (|ArcTrigonometricFunctionCategory|)
                 (|HyperbolicFunctionCategory|)
                 (|ArcHyperbolicFunctionCategory|)
                 (|ElementaryFunctionCategory|) (|RadicalCategory|)
                 (|RetractableTo| 86) (|ConvertibleTo| 245)
                 (|ConvertibleTo| 260) (|ConvertibleTo| 261)
                 (|RetractableTo| 153) (|RetractableTo| 9) (|Eltable| 7 $$)
                 (|InnerEvalable| 7 7) (|InnerEvalable| 86 7)
                 (|ConvertibleTo| 247) (|ConvertibleTo| 246) (|Type|))
              (|makeByteWordVec2| 281
                                  '(0 6 0 14 0 7 0 15 0 7 0 16 1 7 0 6 18 1 6 0
                                    9 22 0 6 0 25 2 7 0 6 26 27 2 7 0 0 0 28 1
                                    33 32 0 34 0 36 0 37 1 33 6 0 38 1 6 32 0
                                    39 1 33 0 0 40 0 9 0 41 2 9 0 0 0 42 2 36 0
                                    35 0 43 1 36 0 44 45 1 7 33 0 46 1 36 32 0
                                    48 0 33 0 49 1 36 35 0 50 2 9 32 0 0 51 1
                                    36 0 0 52 2 33 0 6 0 53 0 9 0 54 1 33 0 44
                                    55 1 7 0 33 56 2 7 6 0 26 58 2 6 32 0 0 59
                                    1 7 0 0 60 2 7 32 0 0 62 2 7 0 0 0 65 2 7 0
                                    0 0 67 1 0 32 0 70 2 9 0 26 0 71 2 7 0 0 26
                                    72 1 7 75 0 76 2 7 0 0 0 78 1 6 75 0 80 2 6
                                    0 0 26 81 2 7 33 0 6 82 2 83 33 6 33 84 1 7
                                    86 0 87 1 7 6 0 89 1 7 26 0 92 2 7 26 0 26
                                    94 2 7 0 0 26 96 3 7 0 0 26 26 98 0 100 0
                                    101 2 7 102 0 26 103 1 100 0 102 104 1 100
                                    0 86 105 1 102 0 6 106 1 9 32 0 107 2 100 0
                                    0 0 108 2 100 0 0 9 109 2 100 0 0 0 110 2
                                    100 0 0 0 111 2 0 100 0 9 112 3 7 102 0 26
                                    26 113 3 0 100 0 9 9 114 2 7 75 0 0 115 2 0
                                    75 0 0 116 2 7 6 0 26 117 1 6 0 86 118 2 6
                                    0 0 0 119 2 6 0 0 9 120 2 6 0 0 0 121 2 0 6
                                    0 9 122 1 7 0 0 123 2 7 0 0 26 125 2 7 0
                                    127 0 128 2 7 0 130 0 131 2 9 0 133 0 134 2
                                    7 0 0 133 135 2 6 0 0 86 138 2 0 0 6 0 139
                                    2 0 0 0 86 140 0 6 26 141 1 0 7 0 143 1 0
                                    29 0 144 1 0 0 0 145 2 0 0 0 9 146 2 0 0 7
                                    0 147 2 0 0 0 7 148 2 0 0 0 0 149 2 0 0 7 7
                                    150 1 0 7 0 151 1 0 7 0 152 1 6 0 153 154 1
                                    0 0 153 155 2 156 2 2 153 157 2 0 0 0 153
                                    158 1 156 2 2 159 1 0 0 0 160 1 156 2 2 161
                                    1 0 0 0 162 1 156 2 2 163 1 0 0 0 164 1 156
                                    2 2 165 1 0 0 0 166 1 156 2 2 167 1 0 0 0
                                    168 1 156 2 2 169 1 0 0 0 170 1 156 2 2 171
                                    1 0 0 0 172 1 156 2 2 173 1 0 0 0 174 1 156
                                    2 2 175 1 0 0 0 176 1 156 2 2 177 1 0 0 0
                                    178 1 156 2 2 179 1 0 0 0 180 1 156 2 2 181
                                    1 0 0 0 182 1 156 2 2 183 1 0 0 0 184 1 156
                                    2 2 185 1 0 0 0 186 1 156 2 2 187 1 0 0 0
                                    188 1 156 2 2 189 1 0 0 0 190 1 156 2 2 191
                                    1 0 0 0 192 1 156 2 2 193 1 0 0 0 194 1 156
                                    2 2 195 1 0 0 0 196 1 156 2 2 197 1 0 0 0
                                    198 1 156 2 2 199 1 0 0 0 200 1 156 2 2 201
                                    1 0 0 0 202 1 156 2 2 203 1 0 0 0 204 1 156
                                    2 2 205 1 0 0 0 206 1 156 2 2 207 1 0 0 0
                                    208 1 156 2 2 209 1 0 0 0 210 1 153 0 9 211
                                    1 153 0 0 212 1 0 0 0 213 1 0 0 0 214 1 6
                                    215 0 216 2 215 32 86 0 217 2 6 0 0 86 218
                                    2 0 0 0 86 219 2 221 220 6 86 222 1 6 223 0
                                    224 1 9 223 0 225 2 223 0 0 0 226 1 6 0 0
                                    227 1 223 0 0 228 2 223 0 0 0 229 1 33 32 0
                                    230 2 33 32 0 0 231 1 33 32 0 232 2 223 0 0
                                    233 234 2 223 0 0 0 235 2 237 223 236 0 238
                                    1 86 223 0 239 2 223 0 0 0 240 1 223 0 0
                                    241 2 0 32 0 0 1 1 0 32 0 70 1 34 7 0 1 1 0
                                    277 0 1 1 0 86 0 88 1 2 276 0 1 1 2 0 0 1 1
                                    2 32 0 1 3 0 0 0 9 9 99 2 0 0 0 9 97 1 0 36
                                    0 47 1 0 7 0 11 1 0 29 0 30 1 0 7 0 31 1 38
                                    0 0 192 1 38 0 0 168 2 0 75 0 0 1 1 32 259
                                    258 1 1 5 0 0 1 1 5 275 0 1 1 38 0 0 1 2 32
                                    256 257 258 1 2 27 32 0 0 1 2 5 32 0 0 1 1
                                    38 0 0 188 1 38 0 0 164 1 14 9 0 1 1 0 0 36
                                    57 1 38 0 0 196 1 38 0 0 172 0 0 0 1 1 15
                                    262 0 1 1 15 263 0 1 1 10 264 0 1 1 0 29 0
                                    144 1 15 153 0 1 1 15 9 0 1 1 10 86 0 1 1 0
                                    7 0 143 1 0 0 0 61 2 0 0 9 0 24 2 5 0 0 0 1
                                    1 0 0 0 1 1 20 251 244 1 2 20 252 244 253 1
                                    1 5 267 244 1 2 5 268 244 253 1 1 0 75 0 77
                                    2 2 100 0 9 112 3 2 100 0 9 9 114 0 33 0 1
                                    2 5 0 0 0 1 1 5 270 233 1 1 5 32 0 1 1 14
                                    32 0 1 1 0 32 0 64 0 38 0 1 3 24 254 0 246
                                    254 1 3 23 255 0 247 255 1 1 0 9 0 93 2 0 9
                                    0 9 95 1 0 32 0 1 1 5 0 0 1 1 5 7 0 151 2
                                    38 0 0 9 1 1 16 75 0 1 1 14 32 0 1 2 0 0 0
                                    133 136 2 0 0 130 0 132 2 5 269 233 0 1 1 0
                                    32 0 1 3 0 0 0 277 278 1 3 0 0 0 279 9 1 2
                                    0 0 6 9 19 2 28 0 0 0 1 2 28 0 0 0 1 2 5 0
                                    266 0 1 2 0 0 127 0 129 1 38 0 0 162 1 0 0
                                    0 1 1 0 6 0 1 1 5 0 233 1 2 5 0 0 0 1 2 0 0
                                    9 7 10 1 0 280 0 1 1 5 0 0 145 2 40 0 0 86
                                    219 1 38 0 0 214 0 16 0 1 1 0 281 0 1 2 5
                                    258 258 258 1 1 5 0 233 1 2 5 0 0 0 1 1 34
                                    0 0 1 1 33 7 0 1 1 32 259 258 1 1 32 259
                                    258 1 1 5 275 0 1 2 5 272 0 0 1 3 5 274 0 0
                                    0 1 2 0 0 0 9 126 2 2 75 0 0 116 2 5 269
                                    233 0 1 1 38 0 0 160 3 18 0 0 248 248 1 2
                                    18 0 0 249 1 3 18 0 0 7 7 1 2 18 0 0 250 1
                                    3 19 0 0 86 7 1 3 19 0 0 215 248 1 2 25 33
                                    0 6 85 1 5 26 0 1 2 17 0 0 7 1 2 4 0 0 0 79
                                    2 0 6 0 9 91 2 5 271 0 0 1 1 8 0 0 137 2 8
                                    0 0 26 1 2 7 0 0 86 140 3 7 0 0 86 26 1 2 7
                                    0 0 215 1 3 7 0 0 215 265 1 3 5 0 0 266 26
                                    1 2 5 0 0 266 1 1 5 0 0 1 1 5 7 0 152 1 0 9
                                    0 12 1 38 0 0 198 1 38 0 0 174 1 38 0 0 194
                                    1 38 0 0 170 1 38 0 0 190 1 38 0 0 166 1 11
                                    245 0 1 1 22 246 0 1 1 21 247 0 1 1 12 260
                                    0 1 1 12 261 0 1 1 41 243 244 1 1 0 0 0 124
                                    1 10 0 86 1 1 38 0 153 155 1 1 0 6 21 1 2 0
                                    0 1 1 0 0 7 20 1 0 0 9 23 1 0 223 0 242 2 0
                                    6 0 9 74 1 42 75 0 1 0 0 26 142 1 0 6 0 90
                                    1 33 7 0 1 1 38 0 0 204 1 38 0 0 180 2 2 32
                                    0 0 1 1 38 0 0 200 1 38 0 0 176 1 38 0 0
                                    208 1 38 0 0 184 2 26 6 0 9 122 1 38 0 0
                                    210 1 38 0 0 186 1 38 0 0 206 1 38 0 0 182
                                    1 38 0 0 202 1 38 0 0 178 1 14 0 0 1 2 38 0
                                    0 153 158 2 38 0 0 0 1 2 5 0 0 9 146 2 0 0
                                    0 26 73 2 0 0 0 133 1 0 0 0 13 0 0 0 17 1 8
                                    0 0 1 2 8 0 0 26 1 2 7 0 0 215 1 2 7 0 0 86
                                    1 3 7 0 0 86 26 1 3 7 0 0 215 265 1 2 5 0 0
                                    266 1 3 5 0 0 266 26 1 2 28 32 0 0 1 2 28
                                    32 0 0 1 2 0 32 0 0 63 2 28 32 0 0 1 2 28
                                    32 0 0 1 2 5 0 7 7 150 2 5 0 0 0 149 2 5 0
                                    0 6 1 2 0 0 0 0 68 1 0 0 0 213 2 0 0 0 0 66
                                    2 38 0 0 153 1 2 38 0 153 0 1 2 5 0 7 0 147
                                    2 5 0 0 7 148 2 0 0 0 6 1 2 0 0 6 0 139 2 0
                                    0 0 0 69 2 0 0 9 0 1 2 0 0 26 0 1 2 0 0 133
                                    0 1)))))
           '|lookupComplete|)) 
