
(/VERSIONCHECK 2) 

(DEFUN |SCENE;createSceneRoot;R$;1| (|bb| $) (VECTOR 1 NIL (CONS 3 |bb|))) 

(DEFUN |SCENE;createSceneRoot;4I$;2| (|minx| |miny| |maxx| |maxy| $)
  (PROG (|bb|)
    (RETURN
     (SEQ
      (LETT |bb|
            (CONS (SPADCALL |minx| |miny| (QREFELT $ 11))
                  (SPADCALL |maxx| |maxy| (QREFELT $ 11)))
            |SCENE;createSceneRoot;4I$;2|)
      (EXIT (VECTOR 1 NIL (CONS 3 |bb|))))))) 

(DEFUN |SCENE;createSceneRoot;$;3| ($)
  (PROG (|bb|)
    (RETURN
     (SEQ
      (LETT |bb|
            (CONS (SPADCALL 0 0 (QREFELT $ 11))
                  (SPADCALL 1200 800 (QREFELT $ 11)))
            |SCENE;createSceneRoot;$;3|)
      (EXIT (VECTOR 1 NIL (CONS 3 |bb|))))))) 

(DEFUN |SCENE;createSceneGroup;$;4| ($) (VECTOR 2 NIL (CONS 7 "empty"))) 

(DEFUN |SCENE;addSceneGroup;2$;5| (|n| $)
  (PROG (|c|)
    (RETURN
     (SEQ (LETT |c| (SPADCALL (QREFELT $ 14)) |SCENE;addSceneGroup;2$;5|)
          (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneLine;L$;6| (|line| $)
  (VECTOR 3 NIL (CONS 0 (LIST |line|)))) 

(DEFUN |SCENE;addSceneLine;$L$;7| (|n| |line| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |line| (QREFELT $ 19)) |SCENE;addSceneLine;$L$;7|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneLines;L$;8| (|lines| $)
  (VECTOR 3 NIL (CONS 0 |lines|))) 

(DEFUN |SCENE;addSceneLines;$L$;9| (|n| |lines| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |lines| (QREFELT $ 22)) |SCENE;addSceneLines;$L$;9|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneArrows;L2Nni$;10| (|lines| |ls| |le| $)
  (PROG (|ar|)
    (RETURN
     (SEQ
      (LETT |ar| (VECTOR |lines| |ls| |le|)
            |SCENE;createSceneArrows;L2Nni$;10|)
      (EXIT (VECTOR 9 NIL (CONS 6 |ar|))))))) 

(DEFUN |SCENE;addSceneArrows;$L2Nni$;11| (|n| |lines| |ls| |le| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |lines| |ls| |le| (QREFELT $ 25))
            |SCENE;addSceneArrows;$L2Nni$;11|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneIFS;LL$;12| (|inx1| |pts1| $)
  (VECTOR 8 NIL (CONS 5 (CONS |inx1| |pts1|)))) 

(DEFUN |SCENE;addSceneIFS;$LL$;13| (|n| |inx1| |pts1| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |inx1| |pts1| (QREFELT $ 28))
            |SCENE;addSceneIFS;$LL$;13|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneIFS;Sifs$;14| (|in1| $)
  (PROG (|pts1| |inx1|)
    (RETURN
     (SEQ
      (LETT |inx1| (SPADCALL |in1| (QREFELT $ 31))
            . #1=(|SCENE;createSceneIFS;Sifs$;14|))
      (LETT |pts1| (SPADCALL |in1| (QREFELT $ 32)) . #1#)
      (EXIT (VECTOR 8 NIL (CONS 5 (CONS |inx1| |pts1|)))))))) 

(DEFUN |SCENE;addSceneIFS;$Sifs$;15| (|n| |in1| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |in1| (QREFELT $ 33)) |SCENE;addSceneIFS;$Sifs$;15|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneBox;Df$;16| (|size| $)
  (PROG (|inx| |pts|)
    (RETURN
     (SEQ
      (LETT |pts|
            (LIST (SPADCALL |size| (MINUS-DF |size|) |size| (QREFELT $ 36))
                  (SPADCALL |size| |size| |size| (QREFELT $ 36))
                  (SPADCALL (MINUS-DF |size|) |size| |size| (QREFELT $ 36))
                  (SPADCALL (MINUS-DF |size|) (MINUS-DF |size|) |size|
                            (QREFELT $ 36))
                  (SPADCALL (MINUS-DF |size|) (MINUS-DF |size|)
                            (MINUS-DF |size|) (QREFELT $ 36))
                  (SPADCALL (MINUS-DF |size|) |size| (MINUS-DF |size|)
                            (QREFELT $ 36))
                  (SPADCALL |size| |size| (MINUS-DF |size|) (QREFELT $ 36))
                  (SPADCALL |size| (MINUS-DF |size|) (MINUS-DF |size|)
                            (QREFELT $ 36)))
            . #1=(|SCENE;createSceneBox;Df$;16|))
      (LETT |inx|
            (LIST (LIST 0 1 2 3) (LIST 4 5 6 7) (LIST 7 6 1 0) (LIST 3 2 5 4)
                  (LIST 1 6 5 2) (LIST 3 4 7 0))
            . #1#)
      (EXIT (SPADCALL |inx| |pts| (QREFELT $ 28))))))) 

(DEFUN |SCENE;addSceneBox;$Df$;17| (|n| |size| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |size| (QREFELT $ 37)) |SCENE;addSceneBox;$Df$;17|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneText;R$;18| (|text| $) (VECTOR 5 NIL (CONS 2 |text|))) 

(DEFUN |SCENE;addSceneText;$R$;19| (|n| |text| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |text| (QREFELT $ 40)) |SCENE;addSceneText;$R$;19|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneText;SNniPT$;20| (|str| |sz| |pz| $)
  (PROG (|text|)
    (RETURN
     (SEQ
      (LETT |text| (VECTOR |str| |sz| |pz|) |SCENE;createSceneText;SNniPT$;20|)
      (EXIT (VECTOR 5 NIL (CONS 2 |text|))))))) 

(DEFUN |SCENE;addSceneText;$SNniPT$;21| (|n| |str| |sz| |pz| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |str| |sz| |pz| (QREFELT $ 43))
            |SCENE;addSceneText;$SNniPT$;21|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneClip;R$;22| (|bb| $) (VECTOR 7 NIL (CONS 3 |bb|))) 

(DEFUN |SCENE;addSceneClip;$R$;23| (|n| |bb| $)
  (PROG (|c|)
    (RETURN
     (SEQ (LETT |c| (SPADCALL |bb| (QREFELT $ 45)) |SCENE;addSceneClip;$R$;23|)
          (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneGrid;DfR$;24| (|stepSize| |bb| $)
  (PROG (|ln| |i| |gp| |stepsy| #1=#:G2058 |stepsx| #2=#:G2057 |maxy| |maxx|
         |miny| |minx|)
    (RETURN
     (SEQ
      (LETT |minx| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #3=(|SCENE;createSceneGrid;DfR$;24|))
      (LETT |miny| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #3#)
      (LETT |maxx| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #3#)
      (LETT |maxy| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #3#)
      (LETT |stepsx|
            (PROG1
                (LETT #2# (TRUNCATE (DIV-DF (SUB-DF |maxx| |minx|) |stepSize|))
                      . #3#)
              (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|) #2#))
            . #3#)
      (LETT |stepsy|
            (PROG1
                (LETT #1# (TRUNCATE (DIV-DF (SUB-DF |maxy| |miny|) |stepSize|))
                      . #3#)
              (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
            . #3#)
      (LETT |gp| (SPADCALL (QREFELT $ 14)) . #3#)
      (SEQ (LETT |i| 1 . #3#) G190
           (COND ((QSGREATERP |i| |stepsx|) #4=(GO G191)))
           (SEQ
            (EXIT
             (LETT |ln|
                   (SPADCALL |gp|
                             (LIST
                              (SPADCALL
                               (ADD-DF |minx|
                                       (MUL-DF
                                        (FLOAT |i| MOST-POSITIVE-DOUBLE-FLOAT)
                                        |stepSize|))
                               |miny| (QREFELT $ 49))
                              (SPADCALL
                               (ADD-DF |minx|
                                       (MUL-DF
                                        (FLOAT |i| MOST-POSITIVE-DOUBLE-FLOAT)
                                        |stepSize|))
                               |maxy| (QREFELT $ 49)))
                             (QREFELT $ 20))
                   . #3#)))
           (LETT |i| (QSADD1 |i|) . #3#) #5=(GO G190) G191 (EXIT NIL))
      (SEQ (LETT |i| 1 . #3#) G190 (COND ((QSGREATERP |i| |stepsy|) #4#))
           (SEQ
            (EXIT
             (LETT |ln|
                   (SPADCALL |gp|
                             (LIST
                              (SPADCALL |minx|
                                        (ADD-DF |miny|
                                                (MUL-DF
                                                 (FLOAT |i|
                                                        MOST-POSITIVE-DOUBLE-FLOAT)
                                                 |stepSize|))
                                        (QREFELT $ 49))
                              (SPADCALL |maxx|
                                        (ADD-DF |miny|
                                                (MUL-DF
                                                 (FLOAT |i|
                                                        MOST-POSITIVE-DOUBLE-FLOAT)
                                                 |stepSize|))
                                        (QREFELT $ 49)))
                             (QREFELT $ 20))
                   . #3#)))
           (LETT |i| (QSADD1 |i|) . #3#) #5# G191 (EXIT NIL))
      (EXIT |gp|))))) 

(DEFUN |SCENE;addSceneGrid;$DfR$;25| (|n| |stepSize| |bb| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |stepSize| |bb| (QREFELT $ 50))
            |SCENE;addSceneGrid;$DfR$;25|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneGrid;R$;26| (|bb| $)
  (PROG (|gd3| |mt3| |gd2| |mt2| |gd1| |mt1| |gp| |stepSize| |maxx| |minx|)
    (RETURN
     (SEQ
      (LETT |minx| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #1=(|SCENE;createSceneGrid;R$;26|))
      (LETT |maxx| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #1#)
      (LETT |stepSize| (DIV-DF-I (SUB-DF |maxx| |minx|) 100) . #1#)
      (LETT |gp| (SPADCALL (QREFELT $ 14)) . #1#)
      (LETT |mt1|
            (SPADCALL |gp|
                      (VECTOR 1.0 "blue" "blue"
                              (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                        (QREFELT $ 55)))
                      (QREFELT $ 57))
            . #1#)
      (LETT |gd1| (SPADCALL |mt1| |stepSize| |bb| (QREFELT $ 51)) . #1#)
      (LETT |mt2|
            (SPADCALL |gp|
                      (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "blue"
                              "blue"
                              (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                        (QREFELT $ 55)))
                      (QREFELT $ 57))
            . #1#)
      (LETT |gd2|
            (SPADCALL |mt2|
                      (MUL-DF |stepSize| (FLOAT 5 MOST-POSITIVE-DOUBLE-FLOAT))
                      |bb| (QREFELT $ 51))
            . #1#)
      (LETT |mt3|
            (SPADCALL |gp|
                      (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "red" "red"
                              (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                        (QREFELT $ 55)))
                      (QREFELT $ 57))
            . #1#)
      (LETT |gd3|
            (SPADCALL |mt3|
                      (MUL-DF |stepSize| (FLOAT 10 MOST-POSITIVE-DOUBLE-FLOAT))
                      |bb| (QREFELT $ 51))
            . #1#)
      (EXIT |gp|))))) 

(DEFUN |SCENE;addSceneGrid;$R$;27| (|n| |bb| $)
  (PROG (|c|)
    (RETURN
     (SEQ (LETT |c| (SPADCALL |bb| (QREFELT $ 58)) |SCENE;addSceneGrid;$R$;27|)
          (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createScenePattern1| (|step| |bb| $)
  (PROG (|ln| |pts| |j| #1=#:G2086 |i| |mt2| #2=#:G2085 |mt1| |gp| |stepSize|
         |maxy| |maxx| |miny| |minx|)
    (RETURN
     (SEQ
      (LETT |minx| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #3=(|SCENE;createScenePattern1|))
      (LETT |miny| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #3#)
      (LETT |maxx| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #3#)
      (LETT |maxy| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #3#)
      (LETT |stepSize| (DIV-DF-I (SUB-DF |maxx| |minx|) 1200) . #3#)
      (LETT |gp| (SPADCALL (QREFELT $ 14)) . #3#)
      (LETT |mt1|
            (SPADCALL |gp|
                      (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "blue"
                              "blue"
                              (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                        (QREFELT $ 55)))
                      (QREFELT $ 57))
            . #3#)
      (SEQ (LETT |i| 1 . #3#) G190
           (COND ((IF (MINUSP |step|) (< |i| 1200) (> |i| 1200)) #4=(GO G191)))
           (SEQ
            (LETT |pts|
                  (PROGN
                   (LETT #2# NIL . #3#)
                   (SEQ (LETT |j| 1 . #3#) G190
                        (COND
                         ((IF (QSMINUSP |step|) (QSLESSP |j| 1200)
                              (QSGREATERP |j| 1200))
                          #4#))
                        (SEQ
                         (EXIT
                          (LETT #2#
                                (CONS
                                 (SPADCALL
                                  (ADD-DF |minx|
                                          (MUL-DF
                                           (FLOAT |i|
                                                  MOST-POSITIVE-DOUBLE-FLOAT)
                                           |stepSize|))
                                  (ADD-DF |miny|
                                          (MUL-DF
                                           (FLOAT |j|
                                                  MOST-POSITIVE-DOUBLE-FLOAT)
                                           |stepSize|))
                                  (QREFELT $ 49))
                                 #2#)
                                . #3#)))
                        (LETT |j| (QSPLUS |j| |step|) . #3#) #5=(GO G190) G191
                        (EXIT (NREVERSE0 #2#))))
                  . #3#)
            (EXIT (LETT |ln| (SPADCALL |mt1| |pts| (QREFELT $ 20)) . #3#)))
           (LETT |i| (+ |i| |step|) . #3#) #5# G191 (EXIT NIL))
      (LETT |mt2|
            (SPADCALL |gp|
                      (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "red" "red"
                              (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                        (QREFELT $ 55)))
                      (QREFELT $ 57))
            . #3#)
      (SEQ (LETT |i| 1 . #3#) G190
           (COND
            ((IF (QSMINUSP |step|) (QSLESSP |i| 1000) (QSGREATERP |i| 1000))
             #4#))
           (SEQ
            (LETT |pts|
                  (PROGN
                   (LETT #1# NIL . #3#)
                   (SEQ (LETT |j| 1 . #3#) G190
                        (COND
                         ((IF (QSMINUSP |step|) (QSLESSP |j| 1200)
                              (QSGREATERP |j| 1200))
                          #4#))
                        (SEQ
                         (EXIT
                          (LETT #1#
                                (CONS
                                 (SPADCALL
                                  (ADD-DF |minx|
                                          (MUL-DF
                                           (FLOAT |j|
                                                  MOST-POSITIVE-DOUBLE-FLOAT)
                                           |stepSize|))
                                  (ADD-DF |miny|
                                          (MUL-DF
                                           (FLOAT |i|
                                                  MOST-POSITIVE-DOUBLE-FLOAT)
                                           |stepSize|))
                                  (QREFELT $ 49))
                                 #1#)
                                . #3#)))
                        (LETT |j| (QSPLUS |j| |step|) . #3#) #5# G191
                        (EXIT (NREVERSE0 #1#))))
                  . #3#)
            (EXIT (LETT |ln| (SPADCALL |mt2| |pts| (QREFELT $ 20)) . #3#)))
           (LETT |i| (QSPLUS |i| |step|) . #3#) #5# G191 (EXIT NIL))
      (EXIT |gp|))))) 

(DEFUN |SCENE;createScenePattern2| (|level| |bb| $)
  (PROG (|ifs2| |ifs| |face1| |midx| |maxy| |maxx| |miny| |minx|)
    (RETURN
     (SEQ
      (LETT |minx| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #1=(|SCENE;createScenePattern2|))
      (LETT |miny| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #1#)
      (LETT |maxx| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #1#)
      (LETT |maxy| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #1#)
      (LETT |midx|
            (MUL-DF (ADD-DF |minx| |maxx|)
                    (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                              (QREFELT $ 55)))
            . #1#)
      (LETT |face1|
            (LIST (SPADCALL |midx| |miny| (QREFELT $ 49))
                  (SPADCALL |minx| |maxy| (QREFELT $ 49))
                  (SPADCALL |maxx| |maxy| (QREFELT $ 49)))
            . #1#)
      (LETT |ifs| (SPADCALL |face1| (QREFELT $ 60)) . #1#)
      (LETT |ifs2| (SPADCALL |ifs| |level| (QREFELT $ 61)) . #1#)
      (EXIT
       (SPADCALL (SPADCALL |ifs2| (QREFELT $ 31))
                 (SPADCALL |ifs2| (QREFELT $ 32)) (QREFELT $ 28))))))) 

(DEFUN |SCENE;subdivideLine| (|level| |inLine| $)
  (PROG (#1=#:G2108 |res| |lastPt| |midpt| #2=#:G2111 |x|)
    (RETURN
     (SEQ
      (COND ((EQL |level| 0) |inLine|)
            ('T
             (SEQ (LETT |res| NIL . #3=(|SCENE;subdivideLine|))
                  (SEQ (LETT |x| 1 . #3#) (LETT #2# (LENGTH |inLine|) . #3#)
                       G190 (COND ((QSGREATERP |x| #2#) (GO G191)))
                       (SEQ
                        (COND
                         ((NULL (EQL |x| 1))
                          (SEQ
                           (LETT |midpt|
                                 (SPADCALL
                                  (SPADCALL (SPADCALL 5 -1 10 (QREFELT $ 54))
                                            (QREFELT $ 55))
                                  (SPADCALL |lastPt|
                                            (SPADCALL |inLine| |x|
                                                      (QREFELT $ 62))
                                            (QREFELT $ 63))
                                  (QREFELT $ 64))
                                 . #3#)
                           (EXIT
                            (LETT |res| (SPADCALL |res| |midpt| (QREFELT $ 65))
                                  . #3#)))))
                        (LETT |lastPt| (SPADCALL |inLine| |x| (QREFELT $ 62))
                              . #3#)
                        (EXIT
                         (LETT |res|
                               (SPADCALL |res|
                                         (SPADCALL |inLine| |x| (QREFELT $ 62))
                                         (QREFELT $ 65))
                               . #3#)))
                       (LETT |x| (QSADD1 |x|) . #3#) (GO G190) G191 (EXIT NIL))
                  (EXIT
                   (|SCENE;subdivideLine|
                    (PROG1 (LETT #1# (- |level| 1) . #3#)
                      (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|) #1#))
                    |res| $))))))))) 

(DEFUN |SCENE;createScenePattern3| (|level| |bb| $)
  (PROG (|ln| |lev2| |pts2| #1=#:G2126 |l2| |pts| #2=#:G2125 |j| #3=#:G2124
         #4=#:G2123 |i| #5=#:G2122 |ycoords| |xcoords| |scale| |maxy| |maxx|
         |miny| |minx|)
    (RETURN
     (SEQ
      (LETT |minx| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #6=(|SCENE;createScenePattern3|))
      (LETT |miny| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #6#)
      (LETT |maxx| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #6#)
      (LETT |maxy| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #6#)
      (LETT |scale| (DIV-DF-I (SUB-DF |maxx| |minx|) 1000) . #6#)
      (LETT |xcoords|
            (LIST (LIST 0 0 500 1000 1000 0) (LIST 150 350 350 150 150)
                  (LIST 100 400 400 100 100) (LIST 600 900 900 600 600)
                  (LIST 600 900 900 600 600))
            . #6#)
      (LETT |ycoords|
            (LIST (LIST 0 800 1000 800 0 0) (LIST 0 0 300 300 0)
                  (LIST 500 500 700 700 500) (LIST 500 500 700 700 500)
                  (LIST 100 100 300 300 100))
            . #6#)
      (LETT |pts|
            (PROGN
             (LETT #5# NIL . #6#)
             (SEQ (LETT |i| 1 . #6#) (LETT #4# (LENGTH |xcoords|) . #6#) G190
                  (COND ((QSGREATERP |i| #4#) #7=(GO G191)))
                  (SEQ
                   (EXIT
                    (LETT #5#
                          (CONS
                           (PROGN
                            (LETT #3# NIL . #6#)
                            (SEQ (LETT |j| 1 . #6#)
                                 (LETT #2#
                                       (SPADCALL
                                        (SPADCALL |xcoords| |i| (QREFELT $ 67))
                                        (QREFELT $ 68))
                                       . #6#)
                                 G190 (COND ((QSGREATERP |j| #2#) #7#))
                                 (SEQ
                                  (EXIT
                                   (LETT #3#
                                         (CONS
                                          (SPADCALL
                                           (ADD-DF |minx|
                                                   (MUL-DF
                                                    (FLOAT
                                                     (SPADCALL
                                                      (SPADCALL |xcoords| |i|
                                                                (QREFELT $ 67))
                                                      |j| (QREFELT $ 69))
                                                     MOST-POSITIVE-DOUBLE-FLOAT)
                                                    |scale|))
                                           (ADD-DF |miny|
                                                   (MUL-DF
                                                    (FLOAT
                                                     (SPADCALL
                                                      (SPADCALL |ycoords| |i|
                                                                (QREFELT $ 67))
                                                      |j| (QREFELT $ 69))
                                                     MOST-POSITIVE-DOUBLE-FLOAT)
                                                    |scale|))
                                           (QREFELT $ 49))
                                          #3#)
                                         . #6#)))
                                 (LETT |j| (QSADD1 |j|) . #6#) #8=(GO G190)
                                 G191 (EXIT (NREVERSE0 #3#))))
                           #5#)
                          . #6#)))
                  (LETT |i| (QSADD1 |i|) . #6#) #8# G191
                  (EXIT (NREVERSE0 #5#))))
            . #6#)
      (LETT |pts2| NIL . #6#) (LETT |lev2| |level| . #6#)
      (SEQ (LETT |l2| NIL . #6#) (LETT #1# |pts| . #6#) G190
           (COND ((OR (ATOM #1#) (PROGN (LETT |l2| (CAR #1#) . #6#) NIL)) #7#))
           (SEQ
            (LETT |pts2|
                  (SPADCALL |pts2| (|SCENE;subdivideLine| |lev2| |l2| $)
                            (QREFELT $ 70))
                  . #6#)
            (EXIT (COND ((EQL |lev2| |level|) (LETT |lev2| 2 . #6#)))))
           (LETT #1# (CDR #1#) . #6#) #8# G191 (EXIT NIL))
      (EXIT (LETT |ln| (SPADCALL |pts2| (QREFELT $ 22)) . #6#)))))) 

(DEFUN |SCENE;createScenePattern;2NniR$;32| (|ptype| |step| |bb| $)
  (PROG (#1=#:G2130)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((EQL |ptype| 1)
          (PROGN
           (LETT #1# (|SCENE;createScenePattern1| |step| |bb| $)
                 . #2=(|SCENE;createScenePattern;2NniR$;32|))
           (GO #1#))))
        (COND
         ((EQL |ptype| 2)
          (PROGN
           (LETT #1# (|SCENE;createScenePattern2| |step| |bb| $) . #2#)
           (GO #1#))))
        (EXIT (|SCENE;createScenePattern3| |step| |bb| $))))
      #1# (EXIT #1#))))) 

(DEFUN |SCENE;addScenePattern;$2NniR$;33| (|n| |ptype| |step| |bb| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |ptype| |step| |bb| (QREFELT $ 71))
            |SCENE;addScenePattern;$2NniR$;33|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneRuler;NniPTR$;34| (|ptype| |offset| |bb| $)
  (PROG (|str| |d| |pz| #1=#:G2156 |x| |stepI| |gp| |suffix| |zeroes|
         |maxPrimaryNorm| |minPrimaryNorm| |divn| |expStep| |stepSize|
         |maxSecondary| |maxPrimary| |minSecondary| |minPrimary|)
    (RETURN
     (SEQ
      (LETT |minPrimary| (SPADCALL (QCAR |bb|) (QREFELT $ 47))
            . #2=(|SCENE;createSceneRuler;NniPTR$;34|))
      (LETT |minSecondary| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #2#)
      (LETT |maxPrimary| (SPADCALL (QCDR |bb|) (QREFELT $ 47)) . #2#)
      (LETT |maxSecondary| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #2#)
      (COND
       ((EQL |ptype| 2)
        (SEQ (LETT |minPrimary| (SPADCALL (QCAR |bb|) (QREFELT $ 48)) . #2#)
             (LETT |minSecondary| (SPADCALL (QCAR |bb|) (QREFELT $ 47)) . #2#)
             (LETT |maxPrimary| (SPADCALL (QCDR |bb|) (QREFELT $ 48)) . #2#)
             (EXIT
              (LETT |maxSecondary| (SPADCALL (QCDR |bb|) (QREFELT $ 47))
                    . #2#)))))
      (LETT |stepSize| (SUB-DF |maxPrimary| |minPrimary|) . #2#)
      (LETT |expStep|
            (- (TRUNCATE (SPADCALL (ADD-DF |stepSize| 1.0) (QREFELT $ 73))) 1)
            . #2#)
      (LETT |divn| (EXPT-DF-I (FLOAT 10 MOST-POSITIVE-DOUBLE-FLOAT) |expStep|)
            . #2#)
      (LETT |minPrimaryNorm| (DIV-DF |minPrimary| |divn|) . #2#)
      (LETT |maxPrimaryNorm| (DIV-DF |maxPrimary| |divn|) . #2#)
      (LETT |suffix| "" . #2#) (LETT |zeroes| |expStep| . #2#)
      (COND
       ((< 2 |zeroes|)
        (SEQ (LETT |zeroes| (- |zeroes| 3) . #2#) (LETT |suffix| "K" . #2#)
             (EXIT
              (COND
               ((< 2 |zeroes|)
                (SEQ (LETT |zeroes| (- |zeroes| 3) . #2#)
                     (LETT |suffix| "M" . #2#)
                     (EXIT
                      (COND
                       ((< 2 |zeroes|)
                        (SEQ (LETT |zeroes| (- |zeroes| 3) . #2#)
                             (LETT |suffix| "G" . #2#)
                             (EXIT
                              (COND
                               ((< 2 |zeroes|)
                                (SEQ (LETT |zeroes| (- |zeroes| 3) . #2#)
                                     (EXIT
                                      (LETT |suffix| "T" . #2#)))))))))))))))))
      (COND
       ((< |zeroes| 0)
        (SEQ (LETT |zeroes| (+ |zeroes| 3) . #2#) (LETT |suffix| "m" . #2#)
             (EXIT
              (COND
               ((< |zeroes| 0)
                (SEQ (LETT |zeroes| (+ |zeroes| 3) . #2#)
                     (LETT |suffix| "u" . #2#)
                     (EXIT
                      (COND
                       ((< |zeroes| 0)
                        (SEQ (LETT |zeroes| (+ |zeroes| 3) . #2#)
                             (LETT |suffix| "n" . #2#)
                             (EXIT
                              (COND
                               ((< |zeroes| 0)
                                (SEQ (LETT |zeroes| (+ |zeroes| 3) . #2#)
                                     (EXIT
                                      (LETT |suffix| "p" . #2#)))))))))))))))))
      (COND ((< 0 |zeroes|) (LETT |suffix| (STRCONC "0" |suffix|) . #2#)))
      (COND ((< 1 |zeroes|) (LETT |suffix| (STRCONC "0" |suffix|) . #2#)))
      (LETT |gp| (SPADCALL (QREFELT $ 14)) . #2#)
      (LETT |stepI| (COND ((EQL |ptype| 1) 2) ('T 1)) . #2#)
      (SEQ (LETT |x| (TRUNCATE |minPrimaryNorm|) . #2#)
           (LETT #1# (TRUNCATE |maxPrimaryNorm|) . #2#) G190
           (COND ((IF (MINUSP |stepI|) (< |x| #1#) (> |x| #1#)) (GO G191)))
           (SEQ (LETT |str| (|mathObject2String| |x|) . #2#)
                (LETT |pz|
                      (SPADCALL
                       (SPADCALL
                        (MUL-DF (FLOAT |x| MOST-POSITIVE-DOUBLE-FLOAT) |divn|)
                        0.0 (QREFELT $ 49))
                       |offset| (QREFELT $ 63))
                      . #2#)
                (COND
                 ((EQL |ptype| 2)
                  (LETT |pz|
                        (SPADCALL
                         (SPADCALL 0.0
                                   (MUL-DF
                                    (FLOAT |x| MOST-POSITIVE-DOUBLE-FLOAT)
                                    |divn|)
                                   (QREFELT $ 49))
                         |offset| (QREFELT $ 63))
                        . #2#)))
                (COND
                 ((EQL |expStep| -1)
                  (SEQ
                   (COND
                    ((< 0 |x|)
                     (COND
                      ((< |x| 10) (LETT |str| (STRCONC "0." |str|) . #2#)))))
                   (COND ((EQL |x| 10) (LETT |str| "1" . #2#)))
                   (COND
                    ((< 10 |x|)
                     (SEQ (LETT |d| (DIVIDE2 |x| 10) . #2#)
                          (EXIT
                           (LETT |str|
                                 (SPADCALL
                                  (LIST (STRINGIMAGE (QCAR |d|)) "."
                                        (STRINGIMAGE (QCDR |d|)))
                                  (QREFELT $ 75))
                                 . #2#)))))
                   (COND
                    ((< |x| 0)
                     (COND
                      ((< -10 |x|)
                       (LETT |str|
                             (SPADCALL
                              (LIST "-0." (|mathObject2String| (- |x|)))
                              (QREFELT $ 75))
                             . #2#)))))
                   (COND ((EQL |x| -10) (LETT |str| "-1" . #2#)))
                   (EXIT
                    (COND
                     ((< |x| -10)
                      (SEQ (LETT |d| (DIVIDE2 (- |x|) 10) . #2#)
                           (EXIT
                            (LETT |str|
                                  (SPADCALL
                                   (LIST "-" (STRINGIMAGE (QCAR |d|)) "."
                                         (STRINGIMAGE (QCDR |d|)))
                                   (QREFELT $ 75))
                                  . #2#))))))))
                 ((NULL (EQL |x| 0))
                  (LETT |str| (STRCONC |str| |suffix|) . #2#)))
                (EXIT (SPADCALL |gp| |str| 20 |pz| (QREFELT $ 44))))
           (LETT |x| (+ |x| |stepI|) . #2#) (GO G190) G191 (EXIT NIL))
      (EXIT |gp|))))) 

(DEFUN |SCENE;addSceneRuler;$NniPTR$;35| (|n| |ptype| |offset| |bb| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |ptype| |offset| |bb| (QREFELT $ 76))
            |SCENE;addSceneRuler;$NniPTR$;35|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneMaterial;R$;36| (|mat| $)
  (VECTOR 4 NIL (CONS 1 |mat|))) 

(DEFUN |SCENE;addSceneMaterial;$R$;37| (|n| |mat| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |mat| (QREFELT $ 78))
            |SCENE;addSceneMaterial;$R$;37|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneMaterial;Df2S$;38| (|lineW| |lineC| |fillC| $)
  (PROG (|mat|)
    (RETURN
     (SEQ
      (LETT |mat| (VECTOR |lineW| |lineC| |fillC| 1.0)
            |SCENE;createSceneMaterial;Df2S$;38|)
      (EXIT (VECTOR 4 NIL (CONS 1 |mat|))))))) 

(DEFUN |SCENE;addSceneMaterial;$Df2S$;39| (|n| |lineW| |lineC| |fillC| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |lineW| |lineC| |fillC| (QREFELT $ 79))
            |SCENE;addSceneMaterial;$Df2S$;39|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createSceneTransform;St$;40| (|tran| $)
  (VECTOR 6 NIL (CONS 4 |tran|))) 

(DEFUN |SCENE;addSceneTransform;$St$;41| (|n| |tran| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |tran| (QREFELT $ 82))
            |SCENE;addSceneTransform;$St$;41|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createArrows2Din2D;M2SNni$;42| (|ptFun| |uSeg| |vSeg| |numPts| $)
  (PROG (|someV| |arrows| |someU| |lp| |outpt| |inPt| |iu| |iv| |vstep|
         |ustep|)
    (RETURN
     (SEQ (LETT |arrows| NIL . #1=(|SCENE;createArrows2Din2D;M2SNni$;42|))
          (LETT |ustep|
                (DIV-DF-I
                 (SUB-DF (SPADCALL |uSeg| (QREFELT $ 85))
                         (SPADCALL |uSeg| (QREFELT $ 86)))
                 |numPts|)
                . #1#)
          (LETT |vstep|
                (DIV-DF-I
                 (SUB-DF (SPADCALL |vSeg| (QREFELT $ 85))
                         (SPADCALL |vSeg| (QREFELT $ 86)))
                 |numPts|)
                . #1#)
          (LETT |someV| (SPADCALL |vSeg| (QREFELT $ 86)) . #1#)
          (SEQ (LETT |iv| |numPts| . #1#) G190 (COND ((< |iv| 0) #2=(GO G191)))
               (SEQ
                (COND
                 ((ZEROP |iv|)
                  (LETT |someV| (SPADCALL |vSeg| (QREFELT $ 85)) . #1#)))
                (LETT |lp| NIL . #1#)
                (LETT |someU| (SPADCALL |uSeg| (QREFELT $ 86)) . #1#)
                (SEQ (LETT |iu| |numPts| . #1#) G190 (COND ((< |iu| 0) #2#))
                     (SEQ
                      (COND
                       ((ZEROP |iu|)
                        (LETT |someU| (SPADCALL |uSeg| (QREFELT $ 85)) . #1#)))
                      (LETT |inPt| (SPADCALL |someU| |someV| (QREFELT $ 49))
                            . #1#)
                      (LETT |outpt| (SPADCALL |inPt| |ptFun|) . #1#)
                      (LETT |lp| (LIST |inPt| |outpt|) . #1#)
                      (LETT |someU| (ADD-DF |someU| |ustep|) . #1#)
                      (EXIT (LETT |arrows| (CONS |lp| |arrows|) . #1#)))
                     (LETT |iu| (+ |iu| -1) . #1#) #3=(GO G190) G191
                     (EXIT NIL))
                (EXIT (LETT |someV| (ADD-DF |someV| |vstep|) . #1#)))
               (LETT |iv| (+ |iv| -1) . #1#) #3# G191 (EXIT NIL))
          (EXIT (SPADCALL |arrows| 1 0 (QREFELT $ 25))))))) 

(DEFUN |SCENE;addArrows2Din2D;$M2SNni$;43|
       (|n| |ptFun| |uSeg| |vSeg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |ptFun| |uSeg| |vSeg| |numPts| (QREFELT $ 88))
            |SCENE;addArrows2Din2D;$M2SNni$;43|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;addChild!;2$V;44| (|n| |c| $)
  (QSETVELT |n| 1 (SPADCALL (QVELT |n| 1) |c| (QREFELT $ 91)))) 

(PUT '|SCENE;removeChild!;2$V;45| '|SPADreplace|
     '(XLAM (|n| |c|) (|error| "removeChild! not yet implemented"))) 

(DEFUN |SCENE;removeChild!;2$V;45| (|n| |c| $)
  (|error| "removeChild! not yet implemented")) 

(DEFUN |SCENE;setTransform!;$StV;46| (|n| |tran| $)
  (COND
   ((NULL (EQL (QVELT |n| 0) 6))
    (|error| "use setTransform! on transform only"))
   ('T (QSETVELT |n| 2 (CONS 4 |tran|))))) 

(DEFUN |SCENE;pathString| (|pts| |tran| |bb| |sc| |clipEn| |useInteger| $)
  (PROG (|lastValid| |ptStr| |thisStr| |minusy| |pntNum| |valid| |param2|
         #1=#:G2252 |param| #2=#:G2251 |line|)
    (RETURN
     (SEQ (LETT |ptStr| "" . #3=(|SCENE;pathString|))
          (LETT |lastValid| 'T . #3#)
          (SEQ (LETT |line| NIL . #3#) (LETT #2# |pts| . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |line| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ (LETT |pntNum| 0 . #3#)
                    (EXIT
                     (SEQ (LETT |param| NIL . #3#) (LETT #1# |line| . #3#) G190
                          (COND
                           ((OR (ATOM #1#)
                                (PROGN (LETT |param| (CAR #1#) . #3#) NIL))
                            #4#))
                          (SEQ
                           (LETT |param2|
                                 (SPADCALL |tran| |param| (QREFELT $ 94))
                                 . #3#)
                           (LETT |valid|
                                 (COND
                                  (|clipEn|
                                   (SPADCALL |param| (QCAR |bb|) (QCDR |bb|)
                                             (QREFELT $ 96)))
                                  ('T 'T))
                                 . #3#)
                           (COND
                            (|valid|
                             (SEQ (LETT |pntNum| (+ |pntNum| 1) . #3#)
                                  (COND
                                   ((NULL (EQUAL |ptStr| ""))
                                    (LETT |ptStr| (STRCONC |ptStr| " ")
                                          . #3#)))
                                  (COND
                                   (|lastValid|
                                    (SEQ
                                     (COND
                                      ((EQL |pntNum| 1)
                                       (LETT |ptStr| (STRCONC |ptStr| "M")
                                             . #3#)))
                                     (EXIT
                                      (COND
                                       ((EQL |pntNum| 2)
                                        (LETT |ptStr| (STRCONC |ptStr| "L")
                                              . #3#)))))))
                                  (COND
                                   ((NULL |lastValid|)
                                    (LETT |ptStr| (STRCONC |ptStr| "M")
                                          . #3#)))
                                  (LETT |minusy|
                                        (MINUS-DF
                                         (MUL-DF
                                          (SPADCALL |param2| (QREFELT $ 48))
                                          |sc|))
                                        . #3#)
                                  (COND
                                   (|useInteger|
                                    (LETT |thisStr|
                                          (SPADCALL
                                           (LIST
                                            (STRINGIMAGE
                                             (TRUNCATE
                                              (MUL-DF
                                               (SPADCALL |param2|
                                                         (QREFELT $ 47))
                                               |sc|)))
                                            ","
                                            (STRINGIMAGE (TRUNCATE |minusy|)))
                                           (QREFELT $ 75))
                                          . #3#))
                                   ('T
                                    (LETT |thisStr|
                                          (SPADCALL
                                           (LIST
                                            (|mathObject2String|
                                             (MUL-DF
                                              (SPADCALL |param2|
                                                        (QREFELT $ 47))
                                              |sc|))
                                            "," (|mathObject2String| |minusy|))
                                           (QREFELT $ 75))
                                          . #3#)))
                                  (EXIT
                                   (LETT |ptStr| (STRCONC |ptStr| |thisStr|)
                                         . #3#)))))
                           (EXIT (LETT |lastValid| |valid| . #3#)))
                          (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                          (EXIT NIL))))
               (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
          (EXIT |ptStr|))))) 

(DEFUN |SCENE;lineArrow| (|pts| |tran| |bb| |mat| |sc| |clipEn| $)
  (PROG (|nodeEles| |x| |nodeAtts| |linWidth| |ptStr| |thisStr| |minusy|
         |endPoint| |startPoint| |pntNum| |valid| |param2| #1=#:G2266 |param|
         #2=#:G2265 |line|)
    (RETURN
     (SEQ (LETT |nodeEles| NIL . #3=(|SCENE;lineArrow|))
          (SEQ (LETT |line| NIL . #3#) (LETT #2# |pts| . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |line| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ (LETT |pntNum| 0 . #3#) (LETT |ptStr| "" . #3#)
                    (LETT |startPoint| (SPADCALL 0 0 (QREFELT $ 11)) . #3#)
                    (LETT |endPoint| (SPADCALL 0 0 (QREFELT $ 11)) . #3#)
                    (SEQ (LETT |param| NIL . #3#) (LETT #1# |line| . #3#) G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |param| (CAR #1#) . #3#) NIL))
                           #4#))
                         (SEQ
                          (LETT |param2|
                                (SPADCALL |tran| |param| (QREFELT $ 94)) . #3#)
                          (LETT |valid|
                                (COND
                                 (|clipEn|
                                  (SPADCALL |param| (QCAR |bb|) (QCDR |bb|)
                                            (QREFELT $ 96)))
                                 ('T 'T))
                                . #3#)
                          (EXIT
                           (COND
                            (|valid|
                             (SEQ (LETT |pntNum| (+ |pntNum| 1) . #3#)
                                  (COND
                                   ((NULL (EQUAL |ptStr| ""))
                                    (LETT |ptStr| (STRCONC |ptStr| " ")
                                          . #3#)))
                                  (COND
                                   ((EQL |pntNum| 1)
                                    (SEQ
                                     (LETT |ptStr| (STRCONC |ptStr| "M") . #3#)
                                     (EXIT
                                      (LETT |startPoint| |param2| . #3#))))
                                   ('T (LETT |endPoint| |param2| . #3#)))
                                  (COND
                                   ((EQL |pntNum| 2)
                                    (LETT |ptStr| (STRCONC |ptStr| "L")
                                          . #3#)))
                                  (LETT |minusy|
                                        (MINUS-DF
                                         (MUL-DF
                                          (SPADCALL |param2| (QREFELT $ 48))
                                          |sc|))
                                        . #3#)
                                  (LETT |thisStr|
                                        (SPADCALL
                                         (LIST
                                          (|mathObject2String|
                                           (MUL-DF
                                            (SPADCALL |param2| (QREFELT $ 47))
                                            |sc|))
                                          "," (|mathObject2String| |minusy|))
                                         (QREFELT $ 75))
                                        . #3#)
                                  (EXIT
                                   (LETT |ptStr| (STRCONC |ptStr| |thisStr|)
                                         . #3#)))))))
                         (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                         (EXIT NIL))
                    (EXIT
                     (COND
                      ((NULL (EQUAL |ptStr| ""))
                       (SEQ
                        (LETT |linWidth|
                              (DIV-DF
                               (SPADCALL |startPoint| |endPoint|
                                         (QREFELT $ 97))
                               (FLOAT 10 MOST-POSITIVE-DOUBLE-FLOAT))
                              . #3#)
                        (LETT |nodeAtts|
                              (LIST (SPADCALL "d" |ptStr| (QREFELT $ 99))
                                    (SPADCALL "fill" "none" (QREFELT $ 99))
                                    (SPADCALL "stroke" (QVELT |mat| 1)
                                              (QREFELT $ 99))
                                    (SPADCALL "stroke-width"
                                              (|mathObject2String| |linWidth|)
                                              (QREFELT $ 99))
                                    (SPADCALL "style" "marker-end:url(#Arrow)"
                                              (QREFELT $ 99)))
                              . #3#)
                        (LETT |x|
                              (SPADCALL "path" NIL |nodeAtts| (QREFELT $ 102))
                              . #3#)
                        (EXIT
                         (LETT |nodeEles|
                               (SPADCALL |nodeEles| |x| (QREFELT $ 104))
                               . #3#)))))))
               (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
          (EXIT |nodeEles|))))) 

(DEFUN |SCENE;faceString| (|faces| |tran| |bb| |sc| |clipEn| $)
  (PROG (|ptStr| |lastValid| |thisStr| |minusy| |pntNum| |valid| |param2|
         |param| #1=#:G2279 |i| #2=#:G2278 |ln|)
    (RETURN
     (SEQ (LETT |ptStr| "" . #3=(|SCENE;faceString|))
          (LETT |lastValid| 'T . #3#)
          (SEQ (LETT |ln| NIL . #3#) (LETT #2# (QCAR |faces|) . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |ln| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ (LETT |pntNum| 0 . #3#)
                    (SEQ (LETT |i| NIL . #3#) (LETT #1# |ln| . #3#) G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |i| (CAR #1#) . #3#) NIL))
                           #4#))
                         (SEQ
                          (LETT |param|
                                (SPADCALL (QCDR |faces|) (+ |i| 1)
                                          (QREFELT $ 62))
                                . #3#)
                          (LETT |param2|
                                (SPADCALL |tran| |param| (QREFELT $ 94)) . #3#)
                          (LETT |valid|
                                (COND
                                 (|clipEn|
                                  (SPADCALL |param| (QCAR |bb|) (QCDR |bb|)
                                            (QREFELT $ 96)))
                                 ('T 'T))
                                . #3#)
                          (COND
                           (|valid|
                            (SEQ (LETT |pntNum| (+ |pntNum| 1) . #3#)
                                 (COND
                                  ((NULL (EQUAL |ptStr| ""))
                                   (LETT |ptStr| (STRCONC |ptStr| " ") . #3#)))
                                 (COND
                                  (|lastValid|
                                   (SEQ
                                    (COND
                                     ((EQL |pntNum| 1)
                                      (LETT |ptStr| (STRCONC |ptStr| "M")
                                            . #3#)))
                                    (EXIT
                                     (COND
                                      ((EQL |pntNum| 2)
                                       (LETT |ptStr| (STRCONC |ptStr| "L")
                                             . #3#)))))))
                                 (COND
                                  ((NULL |lastValid|)
                                   (LETT |ptStr| (STRCONC |ptStr| "M") . #3#)))
                                 (LETT |minusy|
                                       (MINUS-DF
                                        (MUL-DF
                                         (SPADCALL |param2| (QREFELT $ 48))
                                         |sc|))
                                       . #3#)
                                 (LETT |thisStr|
                                       (SPADCALL
                                        (LIST
                                         (|mathObject2String|
                                          (MUL-DF
                                           (SPADCALL |param2| (QREFELT $ 47))
                                           |sc|))
                                         "," (|mathObject2String| |minusy|))
                                        (QREFELT $ 75))
                                       . #3#)
                                 (EXIT
                                  (LETT |ptStr| (STRCONC |ptStr| |thisStr|)
                                        . #3#)))))
                          (EXIT (LETT |lastValid| |valid| . #3#)))
                         (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191
                         (EXIT NIL))
                    (EXIT (LETT |ptStr| (STRCONC |ptStr| "z") . #3#)))
               (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
          (EXIT |ptStr|))))) 

(DEFUN |SCENE;toSVG;$RStRDf2BXe;50|
       (|n| |mat| |tran| |bb| |scale| |clipEn| |useInteger| $)
  (PROG (|nodeEles| |xch| #1=#:G2316 |ch| #2=#:G2292 |nodeName| #3=#:G2315
         #4=#:G2288 |nodeAtts| #5=#:G2291 |bb2| |mx2| #6=#:G2289 |mn2|
         |clipEn2| |tran2| #7=#:G2290 |param2| |mat2| #8=#:G2287 #9=#:G2286
         |viewBoxStr| |offsety| |offsetx| |scale2| |maxy| |maxx| |miny| |minx|
         |mkr| |mkrAtts| |pth| |pthAtts|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |nodeName| "" . #10=(|SCENE;toSVG;$RStRDf2BXe;50|))
            (LETT |bb2| |bb| . #10#) (LETT |tran2| |tran| . #10#)
            (LETT |mat2| |mat| . #10#) (LETT |clipEn2| |clipEn| . #10#)
            (LETT |scale2| |scale| . #10#) (LETT |nodeEles| NIL . #10#)
            (LETT |nodeAtts| NIL . #10#)
            (COND
             ((EQL (QVELT |n| 0) 1)
              (SEQ (LETT |nodeName| "svg" . #10#)
                   (LETT |pthAtts|
                         (LIST
                          (SPADCALL "d"
                                    "M 0.0,0.0 L 5.0,-5.0 L -12.5,0.0 L 5.0,5.0 L 0.0,0.0 z "
                                    (QREFELT $ 99))
                          (SPADCALL "style"
                                    "fill-rule:evenodd;stroke:#000000;stroke-width:1.0pt;marker-start:none;"
                                    (QREFELT $ 99))
                          (SPADCALL "transform"
                                    "scale(0.4) rotate(180) translate(10,0)"
                                    (QREFELT $ 99)))
                         . #10#)
                   (LETT |pth| (SPADCALL "path" NIL |pthAtts| (QREFELT $ 102))
                         . #10#)
                   (LETT |mkrAtts|
                         (LIST (SPADCALL "orient" "auto" (QREFELT $ 99))
                               (SPADCALL "refY" "0.0" (QREFELT $ 99))
                               (SPADCALL "refX" "0.0" (QREFELT $ 99))
                               (SPADCALL "id" "Arrow" (QREFELT $ 99))
                               (SPADCALL "style" "overflow:visible"
                                         (QREFELT $ 99)))
                         . #10#)
                   (LETT |mkr|
                         (SPADCALL "marker" (LIST |pth|) |mkrAtts|
                                   (QREFELT $ 102))
                         . #10#)
                   (LETT |nodeEles|
                         (LIST
                          (SPADCALL "defs" (LIST |mkr|) NIL (QREFELT $ 102)))
                         . #10#)
                   (LETT |bb2|
                         (PROG2
                             (LETT #6# (QVELT |n| 2) . #10#)
                             (QCDR #6#)
                           (|check-union| (QEQCAR #6# 3)
                                          (|Record| (|:| |mins| (QREFELT $ 6))
                                                    (|:| |maxs| (QREFELT $ 6)))
                                          #6#))
                         . #10#)
                   (LETT |minx| (SPADCALL (QCAR |bb2|) (QREFELT $ 47)) . #10#)
                   (LETT |miny| (SPADCALL (QCAR |bb2|) (QREFELT $ 48)) . #10#)
                   (LETT |maxx| (SPADCALL (QCDR |bb2|) (QREFELT $ 47)) . #10#)
                   (LETT |maxy| (SPADCALL (QCDR |bb2|) (QREFELT $ 48)) . #10#)
                   (LETT |scale2|
                         (DIV-DF (FLOAT 1000 MOST-POSITIVE-DOUBLE-FLOAT)
                                 (SUB-DF |maxx| |minx|))
                         . #10#)
                   (LETT |offsetx| (MINUS-DF |minx|) . #10#)
                   (LETT |offsety| (MINUS-DF |maxy|) . #10#)
                   (LETT |tran2|
                         (SPADCALL |offsetx| |offsety| 0.0 1.0 1.0 1.0
                                   (QREFELT $ 105))
                         . #10#)
                   (COND
                    (|useInteger|
                     (LETT |viewBoxStr|
                           (SPADCALL
                            (LIST "0 0 "
                                  (|mathObject2String|
                                   (TRUNCATE
                                    (MUL-DF (SUB-DF |maxx| |minx|) |scale2|)))
                                  " "
                                  (|mathObject2String|
                                   (TRUNCATE
                                    (MUL-DF (SUB-DF |maxy| |miny|) |scale2|))))
                            (QREFELT $ 75))
                           . #10#))
                    (#11='T
                     (LETT |viewBoxStr|
                           (SPADCALL
                            (LIST "0.0 0.0 "
                                  (|mathObject2String|
                                   (MUL-DF (SUB-DF |maxx| |minx|) |scale2|))
                                  " "
                                  (|mathObject2String|
                                   (MUL-DF (SUB-DF |maxy| |miny|) |scale2|)))
                            (QREFELT $ 75))
                           . #10#)))
                   (EXIT
                    (LETT |nodeAtts|
                          (LIST
                           (SPADCALL "xmlns" "http://www.w3.org/2000/svg"
                                     (QREFELT $ 99))
                           (SPADCALL "width" "12cm" (QREFELT $ 99))
                           (SPADCALL "height" "8cm" (QREFELT $ 99))
                           (SPADCALL "viewBox" |viewBoxStr| (QREFELT $ 99)))
                          . #10#)))))
            (COND ((EQL (QVELT |n| 0) 2) (LETT |nodeName| "g" . #10#)))
            (COND
             ((EQL (QVELT |n| 0) 3)
              (SEQ (LETT |nodeName| "path" . #10#)
                   (LETT |nodeAtts|
                         (LIST
                          (SPADCALL "d"
                                    (|SCENE;pathString|
                                     (PROG2
                                         (LETT #9# (QVELT |n| 2) . #10#)
                                         (QCDR #9#)
                                       (|check-union| (QEQCAR #9# 0)
                                                      (|List|
                                                       (|List| (QREFELT $ 6)))
                                                      #9#))
                                     |tran2| |bb2| |scale2| |clipEn2|
                                     |useInteger| $)
                                    (QREFELT $ 99))
                          (SPADCALL "fill" "none" (QREFELT $ 99))
                          (SPADCALL "stroke" (QVELT |mat2| 1) (QREFELT $ 99))
                          (SPADCALL "stroke-width"
                                    (|mathObject2String| (QVELT |mat2| 0))
                                    (QREFELT $ 99))
                          (SPADCALL "stroke-linecap" "butt" (QREFELT $ 99))
                          (SPADCALL "stroke-linejoin" "miter" (QREFELT $ 99)))
                         . #10#)
                   (EXIT
                    (COND
                     ((LESS-DF (QVELT |mat2| 3)
                               (SPADCALL (SPADCALL 95 -2 10 (QREFELT $ 54))
                                         (QREFELT $ 55)))
                      (LETT |nodeAtts|
                            (SPADCALL |nodeAtts|
                                      (SPADCALL "stroke-opacity"
                                                (|mathObject2String|
                                                 (QVELT |mat2| 3))
                                                (QREFELT $ 99))
                                      (QREFELT $ 106))
                            . #10#)))))))
            (COND
             ((EQL (QVELT |n| 0) 4)
              (SEQ (LETT |nodeName| "g" . #10#)
                   (EXIT
                    (LETT |mat2|
                          (PROG2
                              (LETT #8# (QVELT |n| 2) . #10#)
                              (QCDR #8#)
                            (|check-union| (QEQCAR #8# 1)
                                           (|Record|
                                            (|:| |lineWidth| (|DoubleFloat|))
                                            (|:| |lineCol| (|String|))
                                            (|:| |fillCol| (|String|))
                                            (|:| |matOpacity| (|DoubleFloat|)))
                                           #8#))
                          . #10#)))))
            (COND
             ((EQL (QVELT |n| 0) 5)
              (SEQ (LETT |nodeName| "text" . #10#)
                   (LETT |param2|
                         (SPADCALL |tran|
                                   (QVELT
                                    (PROG2
                                        (LETT #4# (QVELT |n| 2) . #10#)
                                        (QCDR #4#)
                                      (|check-union| (QEQCAR #4# 2)
                                                     (|Record|
                                                      (|:| |txt| (|String|))
                                                      (|:| |siz|
                                                           (|NonNegativeInteger|))
                                                      (|:| |pos|
                                                           (QREFELT $ 6)))
                                                     #4#))
                                    2)
                                   (QREFELT $ 94))
                         . #10#)
                   (LETT |nodeAtts|
                         (LIST
                          (SPADCALL "font-size"
                                    (STRINGIMAGE
                                     (QVELT
                                      (PROG2
                                          (LETT #4# (QVELT |n| 2) . #10#)
                                          (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 2)
                                                       (|Record|
                                                        (|:| |txt| (|String|))
                                                        (|:| |siz|
                                                             (|NonNegativeInteger|))
                                                        (|:| |pos|
                                                             (QREFELT $ 6)))
                                                       #4#))
                                      1))
                                    (QREFELT $ 99))
                          (SPADCALL "x"
                                    (|mathObject2String|
                                     (MUL-DF (SPADCALL |param2| (QREFELT $ 47))
                                             |scale2|))
                                    (QREFELT $ 99))
                          (SPADCALL "y"
                                    (|mathObject2String|
                                     (MINUS-DF
                                      (MUL-DF
                                       (SPADCALL |param2| (QREFELT $ 48))
                                       |scale2|)))
                                    (QREFELT $ 99))
                          (SPADCALL "style" (STRCONC "fill:" (QVELT |mat2| 2))
                                    (QREFELT $ 99)))
                         . #10#)
                   (EXIT
                    (PROGN
                     (LETT #3#
                           (SPADCALL |nodeName|
                                     (QVELT
                                      (PROG2
                                          (LETT #4# (QVELT |n| 2) . #10#)
                                          (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 2)
                                                       (|Record|
                                                        (|:| |txt| (|String|))
                                                        (|:| |siz|
                                                             (|NonNegativeInteger|))
                                                        (|:| |pos|
                                                             (QREFELT $ 6)))
                                                       #4#))
                                      0)
                                     |nodeAtts| (QREFELT $ 107))
                           . #10#)
                     (GO #3#))))))
            (COND
             ((EQL (QVELT |n| 0) 6)
              (SEQ (LETT |nodeName| "g" . #10#)
                   (EXIT
                    (LETT |tran2|
                          (SPADCALL
                           (PROG2
                               (LETT #7# (QVELT |n| 2) . #10#)
                               (QCDR #7#)
                             (|check-union| (QEQCAR #7# 4)
                                            (|STransform| (QREFELT $ 6)) #7#))
                           |tran| (QREFELT $ 108))
                          . #10#)))))
            (COND
             ((EQL (QVELT |n| 0) 7)
              (SEQ (LETT |nodeName| "g" . #10#) (LETT |clipEn2| 'T . #10#)
                   (LETT |mn2|
                         (QCAR
                          (PROG2
                              (LETT #6# (QVELT |n| 2) . #10#)
                              (QCDR #6#)
                            (|check-union| (QEQCAR #6# 3)
                                           (|Record| (|:| |mins| (QREFELT $ 6))
                                                     (|:| |maxs|
                                                          (QREFELT $ 6)))
                                           #6#)))
                         . #10#)
                   (LETT |mx2|
                         (QCDR
                          (PROG2
                              (LETT #6# (QVELT |n| 2) . #10#)
                              (QCDR #6#)
                            (|check-union| (QEQCAR #6# 3)
                                           (|Record| (|:| |mins| (QREFELT $ 6))
                                                     (|:| |maxs|
                                                          (QREFELT $ 6)))
                                           #6#)))
                         . #10#)
                   (EXIT (LETT |bb2| (CONS |mn2| |mx2|) . #10#)))))
            (COND
             ((EQL (QVELT |n| 0) 8)
              (SEQ (LETT |nodeName| "path" . #10#)
                   (LETT |nodeAtts|
                         (LIST
                          (SPADCALL "d"
                                    (|SCENE;faceString|
                                     (PROG2
                                         (LETT #5# (QVELT |n| 2) . #10#)
                                         (QCDR #5#)
                                       (|check-union| (QEQCAR #5# 5)
                                                      (|Record|
                                                       (|:| |inx|
                                                            (|List|
                                                             (|List|
                                                              (|NonNegativeInteger|))))
                                                       (|:| |pts|
                                                            (|List|
                                                             (QREFELT $ 6))))
                                                      #5#))
                                     |tran2| |bb2| |scale2| |clipEn2| $)
                                    (QREFELT $ 99))
                          (SPADCALL "fill" (QVELT |mat2| 2) (QREFELT $ 99))
                          (SPADCALL "stroke" (QVELT |mat2| 1) (QREFELT $ 99))
                          (SPADCALL "stroke-width"
                                    (|mathObject2String| (QVELT |mat2| 0))
                                    (QREFELT $ 99)))
                         . #10#)
                   (EXIT
                    (PROGN
                     (LETT #3#
                           (SPADCALL |nodeName|
                                     (QVELT
                                      (PROG2
                                          (LETT #4# (QVELT |n| 2) . #10#)
                                          (QCDR #4#)
                                        (|check-union| (QEQCAR #4# 2)
                                                       (|Record|
                                                        (|:| |txt| (|String|))
                                                        (|:| |siz|
                                                             (|NonNegativeInteger|))
                                                        (|:| |pos|
                                                             (QREFELT $ 6)))
                                                       #4#))
                                      0)
                                     |nodeAtts| (QREFELT $ 107))
                           . #10#)
                     (GO #3#))))))
            (COND
             ((EQL (QVELT |n| 0) 9)
              (SEQ (LETT |nodeName| "g" . #10#)
                   (EXIT
                    (LETT |nodeEles|
                          (|SCENE;lineArrow|
                           (QVELT
                            (PROG2
                                (LETT #2# (QVELT |n| 2) . #10#)
                                (QCDR #2#)
                              (|check-union| (QEQCAR #2# 6)
                                             (|Record|
                                              (|:| |ln|
                                                   (|List|
                                                    (|List| (QREFELT $ 6))))
                                              (|:| |lstart|
                                                   (|NonNegativeInteger|))
                                              (|:| |lend|
                                                   (|NonNegativeInteger|)))
                                             #2#))
                            0)
                           |tran2| |bb2| |mat2| |scale2| |clipEn2| $)
                          . #10#)))))
            (EXIT
             (COND
              ((< (SPADCALL (QVELT |n| 1) (QREFELT $ 109)) 1)
               (SPADCALL |nodeName| |nodeEles| |nodeAtts| (QREFELT $ 102)))
              (#11#
               (SEQ
                (SEQ (LETT |ch| NIL . #10#) (LETT #1# (QVELT |n| 1) . #10#)
                     G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |ch| (CAR #1#) . #10#) NIL))
                       (GO G191)))
                     (SEQ
                      (LETT |xch|
                            (SPADCALL |ch| |mat2| |tran2| |bb2| |scale2|
                                      |clipEn2| |useInteger| (QREFELT $ 110))
                            . #10#)
                      (EXIT
                       (COND
                        ((NULL (SPADCALL |xch| (QREFELT $ 111)))
                         (LETT |nodeEles|
                               (SPADCALL |nodeEles| |xch| (QREFELT $ 104))
                               . #10#)))))
                     (LETT #1# (CDR #1#) . #10#) (GO G190) G191 (EXIT NIL))
                (EXIT
                 (SPADCALL |nodeName| |nodeEles| |nodeAtts|
                           (QREFELT $ 102)))))))))
      #3# (EXIT #3#))))) 

(DEFUN |SCENE;writeSvg;$SV;51| (|n| |filename| $)
  (PROG (|defaultBounds| |defaultTransform| |defaultMaterial|)
    (RETURN
     (SEQ
      (LETT |defaultMaterial|
            (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "black" "black" 1.0)
            . #1=(|SCENE;writeSvg;$SV;51|))
      (LETT |defaultTransform| (SPADCALL (QREFELT $ 112)) . #1#)
      (LETT |defaultBounds|
            (CONS
             (SPADCALL (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (QREFELT $ 49))
             (SPADCALL (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT)
                       (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT) (QREFELT $ 49)))
            . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL |n| |defaultMaterial| |defaultTransform| |defaultBounds| 1.0
                  'NIL 'NIL (QREFELT $ 110))
        |filename| (QREFELT $ 114))))))) 

(DEFUN |SCENE;writeSvgQuantised;$SV;52| (|n| |filename| $)
  (PROG (|defaultBounds| |defaultTransform| |defaultMaterial|)
    (RETURN
     (SEQ
      (LETT |defaultMaterial|
            (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "black" "black" 1.0)
            . #1=(|SCENE;writeSvgQuantised;$SV;52|))
      (LETT |defaultTransform| (SPADCALL (QREFELT $ 112)) . #1#)
      (LETT |defaultBounds|
            (CONS
             (SPADCALL (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (QREFELT $ 49))
             (SPADCALL (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT)
                       (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT) (QREFELT $ 49)))
            . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL |n| |defaultMaterial| |defaultTransform| |defaultBounds| 1.0
                  'NIL 'T (QREFELT $ 110))
        |filename| (QREFELT $ 114))))))) 

(DEFUN |SCENE;pointString| (|pts| |tran| |bb| $)
  (PROG (|ptStr| |thisStr| |param2| #1=#:G2330 |param| |lastValid|)
    (RETURN
     (SEQ (LETT |ptStr| NIL . #2=(|SCENE;pointString|))
          (LETT |lastValid| 'T . #2#)
          (SEQ (LETT |param| NIL . #2#) (LETT #1# |pts| . #2#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |param| (CAR #1#) . #2#) NIL))
                 (GO G191)))
               (SEQ
                (LETT |param2| (SPADCALL |tran| |param| (QREFELT $ 94)) . #2#)
                (LETT |thisStr|
                      (SPADCALL
                       (LIST
                        (|mathObject2String|
                         (SPADCALL |param2| (QREFELT $ 47)))
                        " "
                        (|mathObject2String|
                         (SPADCALL |param2| (QREFELT $ 48)))
                        " "
                        (|mathObject2String|
                         (SPADCALL |param2| (QREFELT $ 117))))
                       (QREFELT $ 75))
                      . #2#)
                (EXIT
                 (LETT |ptStr| (SPADCALL |ptStr| |thisStr| (QREFELT $ 119))
                       . #2#)))
               (LETT #1# (CDR #1#) . #2#) (GO G190) G191 (EXIT NIL))
          (EXIT |ptStr|))))) 

(DEFUN |SCENE;pointIndexString| (|pts| |tran| |bb| $)
  (PROG (|ptStr| #1=#:G2338 |param| #2=#:G2337 |line|)
    (RETURN
     (SEQ (LETT |ptStr| NIL . #3=(|SCENE;pointIndexString|))
          (SEQ (LETT |line| NIL . #3#) (LETT #2# |pts| . #3#) G190
               (COND
                ((OR (ATOM #2#) (PROGN (LETT |line| (CAR #2#) . #3#) NIL))
                 #4=(GO G191)))
               (SEQ
                (SEQ (LETT |param| NIL . #3#) (LETT #1# |line| . #3#) G190
                     (COND
                      ((OR (ATOM #1#)
                           (PROGN (LETT |param| (CAR #1#) . #3#) NIL))
                       #4#))
                     (SEQ
                      (EXIT
                       (LETT |ptStr|
                             (SPADCALL |ptStr| (|mathObject2String| |param|)
                                       (QREFELT $ 119))
                             . #3#)))
                     (LETT #1# (CDR #1#) . #3#) #5=(GO G190) G191 (EXIT NIL))
                (EXIT
                 (LETT |ptStr| (SPADCALL |ptStr| "-1" (QREFELT $ 119)) . #3#)))
               (LETT #2# (CDR #2#) . #3#) #5# G191 (EXIT NIL))
          (EXIT |ptStr|))))) 

(DEFUN |SCENE;setX3DNodeName| (|typ| $)
  (PROG (|nodeName|)
    (RETURN
     (SEQ (LETT |nodeName| "" . #1=(|SCENE;setX3DNodeName|))
          (COND ((EQL |typ| 1) (LETT |nodeName| "X3D" . #1#)))
          (COND ((EQL |typ| 2) (LETT |nodeName| "Group" . #1#)))
          (COND ((EQL |typ| 3) (LETT |nodeName| "IndexedFaceSet" . #1#)))
          (COND ((EQL |typ| 4) (LETT |nodeName| "Group" . #1#)))
          (COND ((EQL |typ| 5) (LETT |nodeName| "Text" . #1#)))
          (COND ((EQL |typ| 6) (LETT |nodeName| "Transform" . #1#)))
          (COND ((EQL |typ| 7) (LETT |nodeName| "Group" . #1#)))
          (COND ((EQL |typ| 8) (LETT |nodeName| "IndexedFaceSet" . #1#)))
          (COND ((EQL |typ| 9) (LETT |nodeName| "IndexedFaceSet" . #1#)))
          (EXIT |nodeName|))))) 

(DEFUN |SCENE;toX3D;$RStRXe;56| (|n| |mat| |tran| |bb| $)
  (PROG (|nodeEles| |xch| #1=#:G2377 |ch| #2=#:G2375 |ifset| |coord| #3=#:G2353
         |nodeAtts| |ifsR| |meshR| #4=#:G2354 #5=#:G2348 #6=#:G2350 |bb2| |mx2|
         #7=#:G2351 |mn2| |tran2| #8=#:G2352 |mat2| #9=#:G2349 |inner|
         #10=#:G2376 |nodeName|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |nodeName| (|SCENE;setX3DNodeName| (QVELT |n| 0) $)
              . #11=(|SCENE;toX3D;$RStRXe;56|))
        (LETT |bb2| |bb| . #11#) (LETT |tran2| |tran| . #11#)
        (LETT |mat2| |mat| . #11#) (LETT |nodeAtts| NIL . #11#)
        (COND
         ((EQL (QVELT |n| 0) 1)
          (SEQ
           (LETT |bb2|
                 (PROG2
                     (LETT #7# (QVELT |n| 2) . #11#)
                     (QCDR #7#)
                   (|check-union| (QEQCAR #7# 3)
                                  (|Record| (|:| |mins| (QREFELT $ 6))
                                            (|:| |maxs| (QREFELT $ 6)))
                                  #7#))
                 . #11#)
           (LETT |bb2|
                 (PROG2
                     (LETT #7# (QVELT |n| 2) . #11#)
                     (QCDR #7#)
                   (|check-union| (QEQCAR #7# 3)
                                  (|Record| (|:| |mins| (QREFELT $ 6))
                                            (|:| |maxs| (QREFELT $ 6)))
                                  #7#))
                 . #11#)
           (LETT |nodeEles| NIL . #11#)
           (SEQ (LETT |ch| NIL . #11#) (LETT #10# (QVELT |n| 1) . #11#) G190
                (COND
                 ((OR (ATOM #10#) (PROGN (LETT |ch| (CAR #10#) . #11#) NIL))
                  #12=(GO G191)))
                (SEQ
                 (LETT |xch|
                       (SPADCALL |ch| |mat2| |tran2| |bb2| (QREFELT $ 120))
                       . #11#)
                 (EXIT
                  (COND
                   ((NULL (SPADCALL |xch| (QREFELT $ 111)))
                    (LETT |nodeEles|
                          (SPADCALL |nodeEles| |xch| (QREFELT $ 104))
                          . #11#)))))
                (LETT #10# (CDR #10#) . #11#) #13=(GO G190) G191 (EXIT NIL))
           (LETT |inner|
                 (SPADCALL "Scene" |nodeEles| |nodeAtts| (QREFELT $ 102))
                 . #11#)
           (EXIT
            (PROGN
             (LETT #2#
                   (SPADCALL |nodeName| (LIST |inner|) |nodeAtts|
                             (QREFELT $ 102))
                   . #11#)
             (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 4)
          (LETT |mat2|
                (PROG2
                    (LETT #9# (QVELT |n| 2) . #11#)
                    (QCDR #9#)
                  (|check-union| (QEQCAR #9# 1)
                                 (|Record| (|:| |lineWidth| (|DoubleFloat|))
                                           (|:| |lineCol| (|String|))
                                           (|:| |fillCol| (|String|))
                                           (|:| |matOpacity| (|DoubleFloat|)))
                                 #9#))
                . #11#)))
        (COND
         ((EQL (QVELT |n| 0) 6)
          (LETT |tran2|
                (SPADCALL
                 (PROG2
                     (LETT #8# (QVELT |n| 2) . #11#)
                     (QCDR #8#)
                   (|check-union| (QEQCAR #8# 4) (|STransform| (QREFELT $ 6))
                                  #8#))
                 |tran| (QREFELT $ 108))
                . #11#)))
        (COND
         ((EQL (QVELT |n| 0) 7)
          (SEQ
           (LETT |mn2|
                 (QCAR
                  (PROG2
                      (LETT #7# (QVELT |n| 2) . #11#)
                      (QCDR #7#)
                    (|check-union| (QEQCAR #7# 3)
                                   (|Record| (|:| |mins| (QREFELT $ 6))
                                             (|:| |maxs| (QREFELT $ 6)))
                                   #7#)))
                 . #11#)
           (LETT |mx2|
                 (QCDR
                  (PROG2
                      (LETT #7# (QVELT |n| 2) . #11#)
                      (QCDR #7#)
                    (|check-union| (QEQCAR #7# 3)
                                   (|Record| (|:| |mins| (QREFELT $ 6))
                                             (|:| |maxs| (QREFELT $ 6)))
                                   #7#)))
                 . #11#)
           (EXIT (LETT |bb2| (CONS |mn2| |mx2|) . #11#)))))
        (COND
         ((EQL (QVELT |n| 0) 5)
          (LETT |nodeAtts|
                (LIST
                 (SPADCALL "string"
                           (QVELT
                            (PROG2
                                (LETT #6# (QVELT |n| 2) . #11#)
                                (QCDR #6#)
                              (|check-union| (QEQCAR #6# 2)
                                             (|Record| (|:| |txt| (|String|))
                                                       (|:| |siz|
                                                            (|NonNegativeInteger|))
                                                       (|:| |pos|
                                                            (QREFELT $ 6)))
                                             #6#))
                            0)
                           (QREFELT $ 99)))
                . #11#)))
        (COND
         ((EQL (QVELT |n| 0) 3)
          (SEQ
           (LETT |meshR|
                 (SPADCALL
                  (|SPADfirst|
                   (PROG2
                       (LETT #5# (QVELT |n| 2) . #11#)
                       (QCDR #5#)
                     (|check-union| (QEQCAR #5# 0)
                                    (|List| (|List| (QREFELT $ 6))) #5#)))
                  (SPADCALL (SPADCALL 25 -2 10 (QREFELT $ 54)) (QREFELT $ 55))
                  8 (QREFELT $ 121))
                 . #11#)
           (LETT |ifsR| (SPADCALL |meshR| 'NIL (QREFELT $ 122)) . #11#)
           (LETT |nodeAtts|
                 (LIST
                  (SPADCALL "coordIndex"
                            (|SCENE;pointIndexString|
                             (SPADCALL |ifsR| (QREFELT $ 31)) |tran| |bb| $)
                            (QREFELT $ 123)))
                 . #11#)
           (LETT |coord|
                 (SPADCALL "Coordinate" NIL
                           (LIST
                            (SPADCALL "point"
                                      (|SCENE;pointString|
                                       (SPADCALL |ifsR| (QREFELT $ 32)) |tran|
                                       |bb| $)
                                      (QREFELT $ 123)))
                           (QREFELT $ 102))
                 . #11#)
           (LETT |ifset|
                 (SPADCALL |nodeName| (LIST |coord|) |nodeAtts|
                           (QREFELT $ 102))
                 . #11#)
           (EXIT
            (PROGN
             (LETT #2# (SPADCALL "Shape" (LIST |ifset|) NIL (QREFELT $ 102))
                   . #11#)
             (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 9)
          (SEQ
           (LETT |meshR|
                 (SPADCALL
                  (|SPADfirst|
                   (QVELT
                    (PROG2
                        (LETT #4# (QVELT |n| 2) . #11#)
                        (QCDR #4#)
                      (|check-union| (QEQCAR #4# 6)
                                     (|Record|
                                      (|:| |ln|
                                           (|List| (|List| (QREFELT $ 6))))
                                      (|:| |lstart| (|NonNegativeInteger|))
                                      (|:| |lend| (|NonNegativeInteger|)))
                                     #4#))
                    0))
                  (SPADCALL (SPADCALL 25 -2 10 (QREFELT $ 54)) (QREFELT $ 55))
                  8 (QREFELT $ 121))
                 . #11#)
           (LETT |ifsR| (SPADCALL |meshR| 'NIL (QREFELT $ 122)) . #11#)
           (LETT |nodeAtts|
                 (LIST
                  (SPADCALL "coordIndex"
                            (|SCENE;pointIndexString|
                             (SPADCALL |ifsR| (QREFELT $ 31)) |tran| |bb| $)
                            (QREFELT $ 123)))
                 . #11#)
           (LETT |coord|
                 (SPADCALL "Coordinate" NIL
                           (LIST
                            (SPADCALL "point"
                                      (|SCENE;pointString|
                                       (SPADCALL |ifsR| (QREFELT $ 32)) |tran|
                                       |bb| $)
                                      (QREFELT $ 123)))
                           (QREFELT $ 102))
                 . #11#)
           (LETT |ifset|
                 (SPADCALL |nodeName| (LIST |coord|) |nodeAtts|
                           (QREFELT $ 102))
                 . #11#)
           (EXIT
            (PROGN
             (LETT #2# (SPADCALL "Shape" (LIST |ifset|) NIL (QREFELT $ 102))
                   . #11#)
             (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 8)
          (SEQ
           (LETT |nodeAtts|
                 (LIST
                  (SPADCALL "coordIndex"
                            (|SCENE;pointIndexString|
                             (QCAR
                              (PROG2
                                  (LETT #3# (QVELT |n| 2) . #11#)
                                  (QCDR #3#)
                                (|check-union| (QEQCAR #3# 5)
                                               (|Record|
                                                (|:| |inx|
                                                     (|List|
                                                      (|List|
                                                       (|NonNegativeInteger|))))
                                                (|:| |pts|
                                                     (|List| (QREFELT $ 6))))
                                               #3#)))
                             |tran| |bb| $)
                            (QREFELT $ 123)))
                 . #11#)
           (LETT |coord|
                 (SPADCALL "Coordinate" NIL
                           (LIST
                            (SPADCALL "point"
                                      (|SCENE;pointString|
                                       (QCDR
                                        (PROG2
                                            (LETT #3# (QVELT |n| 2) . #11#)
                                            (QCDR #3#)
                                          (|check-union| (QEQCAR #3# 5)
                                                         (|Record|
                                                          (|:| |inx|
                                                               (|List|
                                                                (|List|
                                                                 (|NonNegativeInteger|))))
                                                          (|:| |pts|
                                                               (|List|
                                                                (QREFELT $
                                                                         6))))
                                                         #3#)))
                                       |tran2| |bb2| $)
                                      (QREFELT $ 123)))
                           (QREFELT $ 102))
                 . #11#)
           (LETT |ifset|
                 (SPADCALL |nodeName| (LIST |coord|) |nodeAtts|
                           (QREFELT $ 102))
                 . #11#)
           (EXIT
            (PROGN
             (LETT #2# (SPADCALL "Shape" (LIST |ifset|) NIL (QREFELT $ 102))
                   . #11#)
             (GO #2#))))))
        (EXIT
         (COND
          ((< (SPADCALL (QVELT |n| 1) (QREFELT $ 109)) 1)
           (SPADCALL |nodeName| NIL |nodeAtts| (QREFELT $ 102)))
          ('T
           (SEQ (LETT |nodeEles| NIL . #11#)
                (SEQ (LETT |ch| NIL . #11#) (LETT #1# (QVELT |n| 1) . #11#)
                     G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |ch| (CAR #1#) . #11#) NIL))
                       #12#))
                     (SEQ
                      (LETT |xch|
                            (SPADCALL |ch| |mat2| |tran2| |bb2|
                                      (QREFELT $ 120))
                            . #11#)
                      (EXIT
                       (COND
                        ((NULL (SPADCALL |xch| (QREFELT $ 111)))
                         (LETT |nodeEles|
                               (SPADCALL |nodeEles| |xch| (QREFELT $ 104))
                               . #11#)))))
                     (LETT #1# (CDR #1#) . #11#) #13# G191 (EXIT NIL))
                (EXIT
                 (SPADCALL |nodeName| |nodeEles| |nodeAtts|
                           (QREFELT $ 102)))))))))
      #2# (EXIT #2#))))) 

(DEFUN |SCENE;writeX3d;$SV;57| (|n| |filename| $)
  (PROG (|defaultBounds| |defaultTransform| |defaultMaterial|)
    (RETURN
     (SEQ
      (LETT |defaultMaterial|
            (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "black" "black" 1.0)
            . #1=(|SCENE;writeX3d;$SV;57|))
      (LETT |defaultTransform| (SPADCALL (QREFELT $ 112)) . #1#)
      (LETT |defaultBounds|
            (CONS
             (SPADCALL (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (QREFELT $ 49))
             (SPADCALL (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT)
                       (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT) (QREFELT $ 49)))
            . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL |n| |defaultMaterial| |defaultTransform| |defaultBounds|
                  (QREFELT $ 120))
        |filename| (QREFELT $ 114))))))) 

(DEFUN |SCENE;toObj;$RRRStRV;58|
       (|n| |ptLst| |indexLst| |indexNxt| |tran| |bb| $)
  (PROG (#1=#:G2436 |ch| #2=#:G2422 |i2| #3=#:G2435 |j| #4=#:G2434 #5=#:G2433
         |k| #6=#:G2432 |p1| #7=#:G2393 |i1| #8=#:G2431 #9=#:G2430 #10=#:G2429
         #11=#:G2428 |ifsR| |meshR| #12=#:G2388 #13=#:G2427 #14=#:G2426
         #15=#:G2425 #16=#:G2424 |bb2| |mx2| #17=#:G2391 |mn2| |tran2|
         #18=#:G2392 #19=#:G2423 |mx| |mn| |offsety| |offsetRequired| |offsetx|
         |miny| |minx| |nodeName|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |nodeName| (|SCENE;setX3DNodeName| (QVELT |n| 0) $)
              . #20=(|SCENE;toObj;$RRRStRV;58|))
        (LETT |bb2| |bb| . #20#) (LETT |tran2| |tran| . #20#)
        (COND
         ((EQL (QVELT |n| 0) 1)
          (SEQ
           (LETT |bb2|
                 (PROG2
                     (LETT #17# (QVELT |n| 2) . #20#)
                     (QCDR #17#)
                   (|check-union| (QEQCAR #17# 3)
                                  (|Record| (|:| |mins| (QREFELT $ 6))
                                            (|:| |maxs| (QREFELT $ 6)))
                                  #17#))
                 . #20#)
           (LETT |minx| (SPADCALL (QCAR |bb2|) (QREFELT $ 47)) . #20#)
           (LETT |miny| (SPADCALL (QCAR |bb2|) (QREFELT $ 48)) . #20#)
           (LETT |offsetx| 0.0 . #20#) (LETT |offsety| 0.0 . #20#)
           (LETT |offsetRequired| 'NIL . #20#)
           (COND
            ((LESS-DF |minx| 0.0)
             (SEQ (LETT |offsetRequired| 'T . #20#)
                  (EXIT (LETT |offsetx| (MINUS-DF |minx|) . #20#)))))
           (COND
            ((LESS-DF |miny| 0.0)
             (SEQ (LETT |offsetRequired| 'T . #20#)
                  (EXIT (LETT |offsety| (MINUS-DF |miny|) . #20#)))))
           (EXIT
            (COND
             (|offsetRequired|
              (SEQ
               (LETT |mn|
                     (SPADCALL
                      (ADD-DF (SPADCALL (QCAR |bb2|) (QREFELT $ 47)) |offsetx|)
                      (ADD-DF (SPADCALL (QCAR |bb2|) (QREFELT $ 48)) |offsety|)
                      (QREFELT $ 49))
                     . #20#)
               (LETT |mx|
                     (SPADCALL
                      (ADD-DF (SPADCALL (QCDR |bb2|) (QREFELT $ 47)) |offsetx|)
                      (ADD-DF (SPADCALL (QCDR |bb2|) (QREFELT $ 48)) |offsety|)
                      (QREFELT $ 49))
                     . #20#)
               (LETT |bb2| (CONS |mn| |mx|) . #20#)
               (EXIT
                (LETT |tran2|
                      (SPADCALL |offsetx| |offsety| 0.0 1.0 1.0 1.0
                                (QREFELT $ 105))
                      . #20#)))))))))
        (COND
         ((EQL (QVELT |n| 0) 1)
          (SEQ
           (LETT |bb2|
                 (PROG2
                     (LETT #17# (QVELT |n| 2) . #20#)
                     (QCDR #17#)
                   (|check-union| (QEQCAR #17# 3)
                                  (|Record| (|:| |mins| (QREFELT $ 6))
                                            (|:| |maxs| (QREFELT $ 6)))
                                  #17#))
                 . #20#)
           (SEQ (LETT |ch| NIL . #20#) (LETT #19# (QVELT |n| 1) . #20#) G190
                (COND
                 ((OR (ATOM #19#) (PROGN (LETT |ch| (CAR #19#) . #20#) NIL))
                  #21=(GO G191)))
                (SEQ
                 (EXIT
                  (SPADCALL |ch| |ptLst| |indexLst| |indexNxt| |tran2| |bb2|
                            (QREFELT $ 128))))
                (LETT #19# (CDR #19#) . #20#) #22=(GO G190) G191 (EXIT NIL))
           (EXIT (PROGN (LETT #2# (|Void|) . #20#) (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 6)
          (LETT |tran2|
                (SPADCALL
                 (PROG2
                     (LETT #18# (QVELT |n| 2) . #20#)
                     (QCDR #18#)
                   (|check-union| (QEQCAR #18# 4) (|STransform| (QREFELT $ 6))
                                  #18#))
                 |tran| (QREFELT $ 108))
                . #20#)))
        (COND
         ((EQL (QVELT |n| 0) 7)
          (SEQ
           (LETT |mn2|
                 (QCAR
                  (PROG2
                      (LETT #17# (QVELT |n| 2) . #20#)
                      (QCDR #17#)
                    (|check-union| (QEQCAR #17# 3)
                                   (|Record| (|:| |mins| (QREFELT $ 6))
                                             (|:| |maxs| (QREFELT $ 6)))
                                   #17#)))
                 . #20#)
           (LETT |mx2|
                 (QCDR
                  (PROG2
                      (LETT #17# (QVELT |n| 2) . #20#)
                      (QCDR #17#)
                    (|check-union| (QEQCAR #17# 3)
                                   (|Record| (|:| |mins| (QREFELT $ 6))
                                             (|:| |maxs| (QREFELT $ 6)))
                                   #17#)))
                 . #20#)
           (LETT |bb2| (CONS |mn2| |mx2|) . #20#)
           (EXIT (PROGN (LETT #2# (|Void|) . #20#) (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 3)
          (SEQ
           (LETT |meshR|
                 (SPADCALL
                  (|SPADfirst|
                   (PROG2
                       (LETT #12# (QVELT |n| 2) . #20#)
                       (QCDR #12#)
                     (|check-union| (QEQCAR #12# 0)
                                    (|List| (|List| (QREFELT $ 6))) #12#)))
                  (SPADCALL (SPADCALL 25 -2 10 (QREFELT $ 54)) (QREFELT $ 55))
                  8 (QREFELT $ 121))
                 . #20#)
           (LETT |ifsR| (SPADCALL |meshR| 'NIL (QREFELT $ 122)) . #20#)
           (LETT |i1| (SPADCALL |ifsR| (QREFELT $ 31)) . #20#)
           (LETT |p1| (SPADCALL |ifsR| (QREFELT $ 32)) . #20#)
           (LETT |i2|
                 (PROGN
                  (LETT #16# NIL . #20#)
                  (SEQ (LETT |k| NIL . #20#) (LETT #15# |i1| . #20#) G190
                       (COND
                        ((OR (ATOM #15#)
                             (PROGN (LETT |k| (CAR #15#) . #20#) NIL))
                         #21#))
                       (SEQ
                        (EXIT
                         (LETT #16#
                               (CONS
                                (PROGN
                                 (LETT #14# NIL . #20#)
                                 (SEQ (LETT |j| NIL . #20#)
                                      (LETT #13# |k| . #20#) G190
                                      (COND
                                       ((OR (ATOM #13#)
                                            (PROGN
                                             (LETT |j| (CAR #13#) . #20#)
                                             NIL))
                                        #21#))
                                      (SEQ
                                       (EXIT
                                        (LETT #14#
                                              (CONS
                                               (+ |j|
                                                  (SPADCALL |indexNxt|
                                                            (QREFELT $ 129)))
                                               #14#)
                                              . #20#)))
                                      (LETT #13# (CDR #13#) . #20#) #22# G191
                                      (EXIT (NREVERSE0 #14#))))
                                #16#)
                               . #20#)))
                       (LETT #15# (CDR #15#) . #20#) #22# G191
                       (EXIT (NREVERSE0 #16#))))
                 . #20#)
           (SPADCALL |ptLst|
                     (SPADCALL (SPADCALL |ptLst| (QREFELT $ 130)) |p1|
                               (QREFELT $ 131))
                     (QREFELT $ 132))
           (SPADCALL |indexLst|
                     (SPADCALL (SPADCALL |indexLst| (QREFELT $ 133)) |i2|
                               (QREFELT $ 134))
                     (QREFELT $ 135))
           (SPADCALL |indexNxt|
                     (+ (SPADCALL |indexNxt| (QREFELT $ 129)) (LENGTH |p1|))
                     (QREFELT $ 136))
           (EXIT (PROGN (LETT #2# (|Void|) . #20#) (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 9)
          (SEQ
           (LETT |meshR|
                 (SPADCALL
                  (|SPADfirst|
                   (PROG2
                       (LETT #12# (QVELT |n| 2) . #20#)
                       (QCDR #12#)
                     (|check-union| (QEQCAR #12# 0)
                                    (|List| (|List| (QREFELT $ 6))) #12#)))
                  (SPADCALL (SPADCALL 25 -2 10 (QREFELT $ 54)) (QREFELT $ 55))
                  8 (QREFELT $ 121))
                 . #20#)
           (LETT |ifsR| (SPADCALL |meshR| 'NIL (QREFELT $ 122)) . #20#)
           (LETT |i1| (SPADCALL |ifsR| (QREFELT $ 31)) . #20#)
           (LETT |p1| (SPADCALL |ifsR| (QREFELT $ 32)) . #20#)
           (LETT |i2|
                 (PROGN
                  (LETT #11# NIL . #20#)
                  (SEQ (LETT |k| NIL . #20#) (LETT #10# |i1| . #20#) G190
                       (COND
                        ((OR (ATOM #10#)
                             (PROGN (LETT |k| (CAR #10#) . #20#) NIL))
                         #21#))
                       (SEQ
                        (EXIT
                         (LETT #11#
                               (CONS
                                (PROGN
                                 (LETT #9# NIL . #20#)
                                 (SEQ (LETT |j| NIL . #20#)
                                      (LETT #8# |k| . #20#) G190
                                      (COND
                                       ((OR (ATOM #8#)
                                            (PROGN
                                             (LETT |j| (CAR #8#) . #20#)
                                             NIL))
                                        #21#))
                                      (SEQ
                                       (EXIT
                                        (LETT #9#
                                              (CONS
                                               (+ |j|
                                                  (SPADCALL |indexNxt|
                                                            (QREFELT $ 129)))
                                               #9#)
                                              . #20#)))
                                      (LETT #8# (CDR #8#) . #20#) #22# G191
                                      (EXIT (NREVERSE0 #9#))))
                                #11#)
                               . #20#)))
                       (LETT #10# (CDR #10#) . #20#) #22# G191
                       (EXIT (NREVERSE0 #11#))))
                 . #20#)
           (SPADCALL |ptLst|
                     (SPADCALL (SPADCALL |ptLst| (QREFELT $ 130)) |p1|
                               (QREFELT $ 131))
                     (QREFELT $ 132))
           (SPADCALL |indexLst|
                     (SPADCALL (SPADCALL |indexLst| (QREFELT $ 133)) |i2|
                               (QREFELT $ 134))
                     (QREFELT $ 135))
           (SPADCALL |indexNxt|
                     (+ (SPADCALL |indexNxt| (QREFELT $ 129)) (LENGTH |p1|))
                     (QREFELT $ 136))
           (EXIT (PROGN (LETT #2# (|Void|) . #20#) (GO #2#))))))
        (COND
         ((EQL (QVELT |n| 0) 8)
          (SEQ
           (LETT |i1|
                 (QCAR
                  (PROG2
                      (LETT #7# (QVELT |n| 2) . #20#)
                      (QCDR #7#)
                    (|check-union| (QEQCAR #7# 5)
                                   (|Record|
                                    (|:| |inx|
                                         (|List|
                                          (|List| (|NonNegativeInteger|))))
                                    (|:| |pts| (|List| (QREFELT $ 6))))
                                   #7#)))
                 . #20#)
           (LETT |p1|
                 (QCDR
                  (PROG2
                      (LETT #7# (QVELT |n| 2) . #20#)
                      (QCDR #7#)
                    (|check-union| (QEQCAR #7# 5)
                                   (|Record|
                                    (|:| |inx|
                                         (|List|
                                          (|List| (|NonNegativeInteger|))))
                                    (|:| |pts| (|List| (QREFELT $ 6))))
                                   #7#)))
                 . #20#)
           (LETT |i2|
                 (PROGN
                  (LETT #6# NIL . #20#)
                  (SEQ (LETT |k| NIL . #20#) (LETT #5# |i1| . #20#) G190
                       (COND
                        ((OR (ATOM #5#)
                             (PROGN (LETT |k| (CAR #5#) . #20#) NIL))
                         #21#))
                       (SEQ
                        (EXIT
                         (LETT #6#
                               (CONS
                                (PROGN
                                 (LETT #4# NIL . #20#)
                                 (SEQ (LETT |j| NIL . #20#)
                                      (LETT #3# |k| . #20#) G190
                                      (COND
                                       ((OR (ATOM #3#)
                                            (PROGN
                                             (LETT |j| (CAR #3#) . #20#)
                                             NIL))
                                        #21#))
                                      (SEQ
                                       (EXIT
                                        (LETT #4#
                                              (CONS
                                               (+ |j|
                                                  (SPADCALL |indexNxt|
                                                            (QREFELT $ 129)))
                                               #4#)
                                              . #20#)))
                                      (LETT #3# (CDR #3#) . #20#) #22# G191
                                      (EXIT (NREVERSE0 #4#))))
                                #6#)
                               . #20#)))
                       (LETT #5# (CDR #5#) . #20#) #22# G191
                       (EXIT (NREVERSE0 #6#))))
                 . #20#)
           (SPADCALL |ptLst|
                     (SPADCALL (SPADCALL |ptLst| (QREFELT $ 130)) |p1|
                               (QREFELT $ 131))
                     (QREFELT $ 132))
           (SPADCALL |indexLst|
                     (SPADCALL (SPADCALL |indexLst| (QREFELT $ 133)) |i2|
                               (QREFELT $ 134))
                     (QREFELT $ 135))
           (SPADCALL |indexNxt|
                     (+ (SPADCALL |indexNxt| (QREFELT $ 129)) (LENGTH |p1|))
                     (QREFELT $ 136))
           (EXIT (PROGN (LETT #2# (|Void|) . #20#) (GO #2#))))))
        (EXIT
         (COND ((< (SPADCALL (QVELT |n| 1) (QREFELT $ 109)) 1) (|Void|))
               ('T
                (SEQ
                 (SEQ (LETT |ch| NIL . #20#) (LETT #1# (QVELT |n| 1) . #20#)
                      G190
                      (COND
                       ((OR (ATOM #1#)
                            (PROGN (LETT |ch| (CAR #1#) . #20#) NIL))
                        #21#))
                      (SEQ
                       (EXIT
                        (SPADCALL |ch| |ptLst| |indexLst| |indexNxt| |tran2|
                                  |bb2| (QREFELT $ 128))))
                      (LETT #1# (CDR #1#) . #20#) #22# G191 (EXIT NIL))
                 (EXIT (|Void|))))))))
      #2# (EXIT #2#))))) 

(DEFUN |SCENE;writeObj;$SV;59| (|n| |filename| $)
  (PROG (|s| #1=#:G2446 |i| #2=#:G2445 |row| #3=#:G2444 |v| |f1|
         |defaultBounds| |defaultTransform| |indexNxt| |indexLst| |ptLst|)
    (RETURN
     (SEQ
      (LETT |ptLst| (SPADCALL NIL (QREFELT $ 137))
            . #4=(|SCENE;writeObj;$SV;59|))
      (LETT |indexLst| (SPADCALL NIL (QREFELT $ 138)) . #4#)
      (LETT |indexNxt| (SPADCALL 0 (QREFELT $ 139)) . #4#)
      (LETT |defaultTransform| (SPADCALL (QREFELT $ 112)) . #4#)
      (LETT |defaultBounds|
            (CONS
             (SPADCALL (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (QREFELT $ 49))
             (SPADCALL (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT)
                       (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT) (QREFELT $ 49)))
            . #4#)
      (SPADCALL |n| |ptLst| |indexLst| |indexNxt| |defaultTransform|
                |defaultBounds| (QREFELT $ 128))
      (LETT |f1|
            (SPADCALL (SPADCALL |filename| (QREFELT $ 141)) "output"
                      (QREFELT $ 143))
            . #4#)
      (SPADCALL |f1| "# mesh generated by axiom" (QREFELT $ 144))
      (SEQ (LETT |v| NIL . #4#)
           (LETT #3# (SPADCALL |ptLst| (QREFELT $ 130)) . #4#) G190
           (COND
            ((OR (ATOM #3#) (PROGN (LETT |v| (CAR #3#) . #4#) NIL))
             #5=(GO G191)))
           (SEQ
            (EXIT
             (SPADCALL |f1|
                       (SPADCALL
                        (LIST "v "
                              (|mathObject2String|
                               (SPADCALL |v| (QREFELT $ 47)))
                              " "
                              (|mathObject2String|
                               (SPADCALL |v| (QREFELT $ 48)))
                              " "
                              (|mathObject2String|
                               (SPADCALL |v| (QREFELT $ 117))))
                        (QREFELT $ 75))
                       (QREFELT $ 144))))
           (LETT #3# (CDR #3#) . #4#) #6=(GO G190) G191 (EXIT NIL))
      (LETT |s| "" . #4#)
      (SEQ (LETT |row| NIL . #4#)
           (LETT #2# (SPADCALL |indexLst| (QREFELT $ 133)) . #4#) G190
           (COND
            ((OR (ATOM #2#) (PROGN (LETT |row| (CAR #2#) . #4#) NIL)) #5#))
           (SEQ (LETT |s| "f" . #4#)
                (SEQ (LETT |i| NIL . #4#) (LETT #1# |row| . #4#) G190
                     (COND
                      ((OR (ATOM #1#) (PROGN (LETT |i| (CAR #1#) . #4#) NIL))
                       #5#))
                     (SEQ
                      (EXIT
                       (LETT |s|
                             (SPADCALL (LIST |s| " " (STRINGIMAGE (+ |i| 1)))
                                       (QREFELT $ 75))
                             . #4#)))
                     (LETT #1# (CDR #1#) . #4#) #6# G191 (EXIT NIL))
                (EXIT (SPADCALL |f1| |s| (QREFELT $ 144))))
           (LETT #2# (CDR #2#) . #4#) #6# G191 (EXIT NIL))
      (SPADCALL |f1| (QREFELT $ 145)) (EXIT (|Void|)))))) 

(DEFUN |SCENE;writeVRML;$SV;60| (|n| |filename| $)
  (PROG (|defaultBounds| |defaultTransform| |defaultMaterial|)
    (RETURN
     (SEQ
      (LETT |defaultMaterial|
            (VECTOR (FLOAT 2 MOST-POSITIVE-DOUBLE-FLOAT) "black" "black" 1.0)
            . #1=(|SCENE;writeVRML;$SV;60|))
      (LETT |defaultTransform| (SPADCALL (QREFELT $ 112)) . #1#)
      (LETT |defaultBounds|
            (CONS
             (SPADCALL (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (MINUS-DF (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT))
                       (QREFELT $ 49))
             (SPADCALL (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT)
                       (FLOAT 9000 MOST-POSITIVE-DOUBLE-FLOAT) (QREFELT $ 49)))
            . #1#)
      (EXIT
       (SPADCALL
        (SPADCALL |n| |defaultMaterial| |defaultTransform| |defaultBounds|
                  (QREFELT $ 120))
        |filename| (QREFELT $ 147))))))) 

(DEFUN |SCENE;Fnan?| (|x| $) (COND ((EQL-DF |x| |x|) 'NIL) ('T 'T))) 

(DEFUN |SCENE;applyfxTrap| (|ff| |f| $)
  (PROG (|r| |s|)
    (RETURN
     (SEQ
      (LETT |s| (|trapNumericErrors| (SPADCALL |f| |ff|))
            . #1=(|SCENE;applyfxTrap|))
      (EXIT
       (COND ((QEQCAR |s| 1) 0.0)
             (#2='T
              (SEQ (LETT |r| (QCDR |s|) . #1#)
                   (EXIT
                    (COND
                     ((LESS-DF MOST-POSITIVE-DOUBLE-FLOAT |r|)
                      MOST-POSITIVE-DOUBLE-FLOAT)
                     ((LESS-DF |r| MOST-NEGATIVE-DOUBLE-FLOAT)
                      MOST-NEGATIVE-DOUBLE-FLOAT)
                     (#2# |r|))))))))))) 

(DEFUN |SCENE;applyfxyTrap| (|ff| |u| |v| $)
  (PROG (|r| |s|)
    (RETURN
     (SEQ
      (LETT |s| (|trapNumericErrors| (SPADCALL |u| |v| |ff|))
            . #1=(|SCENE;applyfxyTrap|))
      (EXIT
       (COND ((QEQCAR |s| 1) 0.0)
             (#2='T
              (SEQ (LETT |r| (QCDR |s|) . #1#)
                   (EXIT
                    (COND
                     ((LESS-DF MOST-POSITIVE-DOUBLE-FLOAT |r|)
                      MOST-POSITIVE-DOUBLE-FLOAT)
                     ((LESS-DF |r| MOST-NEGATIVE-DOUBLE-FLOAT)
                      MOST-NEGATIVE-DOUBLE-FLOAT)
                     (#2# |r|))))))))))) 

(DEFUN |SCENE;normalize| (|seg| $)
  (PROG (|b| |a|)
    (RETURN
     (SEQ (LETT |a| (SPADCALL |seg| (QREFELT $ 85)) . #1=(|SCENE;normalize|))
          (LETT |b| (SPADCALL |seg| (QREFELT $ 86)) . #1#)
          (EXIT
           (COND
            ((EQL-DF |a| |b|) (|error| "The range specified is too small"))
            ((LESS-DF |a| |b|) (SPADCALL |a| |b| (QREFELT $ 149)))
            ('T (SPADCALL |b| |a| (QREFELT $ 149))))))))) 

(DEFUN |SCENE;checkRange| (|r| $)
  (COND
   ((LESS-DF (SPADCALL |r| (QREFELT $ 86)) (SPADCALL |r| (QREFELT $ 85)))
    (|error| "ranges cannot be negative"))
   ('T |r|))) 

(DEFUN |SCENE;createPlot1Din2D;MSNni$;66| (|f| |tRange| |numPts| $)
  (PROG (|branches| |newl| #1=#:G2479 |p| |p0| |t| |l| #2=#:G2478 |i| |s| |h|)
    (RETURN
     (SEQ (|SCENE;checkRange| |tRange| $)
          (LETT |l| (SPADCALL |tRange| (QREFELT $ 85))
                . #3=(|SCENE;createPlot1Din2D;MSNni$;66|))
          (LETT |h| (SPADCALL |tRange| (QREFELT $ 86)) . #3#)
          (LETT |t| (SPADCALL |l| (QREFELT $ 151)) . #3#)
          (LETT |p0| (SPADCALL (SPADCALL |l| |f|) (QREFELT $ 152)) . #3#)
          (LETT |s|
                (DIV-DF (SUB-DF |h| |l|)
                        (FLOAT (- |numPts| 1) MOST-POSITIVE-DOUBLE-FLOAT))
                . #3#)
          (SEQ (LETT |i| 2 . #3#) (LETT #2# (- |numPts| 1) . #3#) G190
               (COND ((QSGREATERP |i| #2#) #4=(GO G191)))
               (SEQ (LETT |l| (ADD-DF |l| |s|) . #3#)
                    (LETT |t| (CONS |l| |t|) . #3#)
                    (EXIT (LETT |p0| (CONS (SPADCALL |l| |f|) |p0|) . #3#)))
               (LETT |i| (QSADD1 |i|) . #3#) #5=(GO G190) G191 (EXIT NIL))
          (LETT |t| (NREVERSE (CONS |h| |t|)) . #3#)
          (LETT |p0| (NREVERSE (CONS (SPADCALL |h| |f|) |p0|)) . #3#)
          (LETT |branches| NIL . #3#) (LETT |newl| NIL . #3#)
          (SEQ (LETT |p| NIL . #3#) (LETT #1# |p0| . #3#) G190
               (COND
                ((OR (ATOM #1#) (PROGN (LETT |p| (CAR #1#) . #3#) NIL)) #4#))
               (SEQ
                (EXIT
                 (COND
                  ((SPADCALL |p| (QREFELT $ 153))
                   (COND
                    ((NULL (NULL |newl|))
                     (SEQ
                      (LETT |branches|
                            (CONS (LETT |newl| (NREVERSE |newl|) . #3#)
                                  |branches|)
                            . #3#)
                      (EXIT (LETT |newl| NIL . #3#))))))
                  ('T (LETT |newl| (CONS |p| |newl|) . #3#)))))
               (LETT #1# (CDR #1#) . #3#) #5# G191 (EXIT NIL))
          (COND
           ((NULL (NULL |newl|))
            (LETT |branches|
                  (CONS (LETT |newl| (NREVERSE |newl|) . #3#) |branches|)
                  . #3#)))
          (EXIT (SPADCALL |branches| (QREFELT $ 22))))))) 

(DEFUN |SCENE;addPlot1Din2D;$MSNni$;67| (|n| |f| |tRange| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |f| |tRange| |numPts| (QREFELT $ 155))
            |SCENE;addPlot1Din2D;$MSNni$;67|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot1Din2D;MSNni$;68| (|f| |seg| |numPts| $)
  (PROG (|ff|)
    (RETURN
     (SEQ
      (LETT |ff|
            (LIST (CONS #'|SCENE;createPlot1Din2D;MSNni$;68!0| (VECTOR $ |f|)))
            |SCENE;createPlot1Din2D;MSNni$;68|)
      (EXIT
       (SPADCALL (SPADCALL |ff| (QREFELT $ 158)) (|SCENE;normalize| |seg| $)
                 |numPts| (QREFELT $ 155))))))) 

(DEFUN |SCENE;createPlot1Din2D;MSNni$;68!0| (|x| $$)
  (PROG (|f| $)
    (LETT |f| (QREFELT $$ 1) . #1=(|SCENE;createPlot1Din2D;MSNni$;68|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN (SPADCALL |x| (|SCENE;applyfxTrap| |f| |x| $) (QREFELT $ 49)))))) 

(DEFUN |SCENE;addPlot1Din2D;$MSNni$;69| (|n| |f| |seg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |f| |seg| |numPts| (QREFELT $ 160))
            |SCENE;addPlot1Din2D;$MSNni$;69|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot1Din2Dparametric;PpcSNni$;70| (|ppc| |seg| |numPts| $)
  (PROG (|fcn| |g| |f|)
    (RETURN
     (SEQ
      (LETT |f| (SPADCALL |ppc| 1 (QREFELT $ 163))
            . #1=(|SCENE;createPlot1Din2Dparametric;PpcSNni$;70|))
      (LETT |g| (SPADCALL |ppc| 2 (QREFELT $ 163)) . #1#)
      (LETT |fcn|
            (LIST
             (CONS #'|SCENE;createPlot1Din2Dparametric;PpcSNni$;70!0|
                   (VECTOR |g| $ |f|)))
            . #1#)
      (EXIT
       (SPADCALL (SPADCALL |fcn| (QREFELT $ 158)) (|SCENE;normalize| |seg| $)
                 |numPts| (QREFELT $ 155))))))) 

(DEFUN |SCENE;createPlot1Din2Dparametric;PpcSNni$;70!0| (|x| $$)
  (PROG (|f| $ |g|)
    (LETT |f| (QREFELT $$ 2)
          . #1=(|SCENE;createPlot1Din2Dparametric;PpcSNni$;70|))
    (LETT $ (QREFELT $$ 1) . #1#)
    (LETT |g| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|SCENE;applyfxTrap| |f| |x| $) (|SCENE;applyfxTrap| |g| |x| $)
                (QREFELT $ 49)))))) 

(DEFUN |SCENE;addPlot1Din2Dparametric;$PpcSNni$;71|
       (|n| |ppc| |seg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |ppc| |seg| |numPts| (QREFELT $ 164))
            |SCENE;addPlot1Din2Dparametric;$PpcSNni$;71|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot1Din3Dparametric;PscSNni$;72| (|psc| |seg| |numPts| $)
  (PROG (|fcn| |h| |g| |f|)
    (RETURN
     (SEQ
      (LETT |f| (SPADCALL |psc| 1 (QREFELT $ 167))
            . #1=(|SCENE;createPlot1Din3Dparametric;PscSNni$;72|))
      (LETT |g| (SPADCALL |psc| 2 (QREFELT $ 167)) . #1#)
      (LETT |h| (SPADCALL |psc| 3 (QREFELT $ 167)) . #1#)
      (LETT |fcn|
            (CONS #'|SCENE;createPlot1Din3Dparametric;PscSNni$;72!0|
                  (VECTOR |h| |g| $ |f|))
            . #1#)
      (EXIT (SPADCALL |fcn| |seg| |numPts| (QREFELT $ 168))))))) 

(DEFUN |SCENE;createPlot1Din3Dparametric;PscSNni$;72!0| (|x| $$)
  (PROG (|f| $ |g| |h|)
    (LETT |f| (QREFELT $$ 3)
          . #1=(|SCENE;createPlot1Din3Dparametric;PscSNni$;72|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |g| (QREFELT $$ 1) . #1#)
    (LETT |h| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|SCENE;applyfxTrap| |f| |x| $) (|SCENE;applyfxTrap| |g| |x| $)
                (|SCENE;applyfxTrap| |h| |x| $) (QREFELT $ 36)))))) 

(DEFUN |SCENE;addPlot1Din3Dparametric;$PscSNni$;73|
       (|n| |psc| |seg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |psc| |seg| |numPts| (QREFELT $ 169))
            |SCENE;addPlot1Din3Dparametric;$PscSNni$;73|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot1Din3Dparametric;MSNni$;74| (|psc| |seg| |numPts| $)
  (PROG (|p| |t| |l| #1=#:G2518 |i| |s| |h| |tRange| |f|)
    (RETURN
     (SEQ (LETT |f| |psc| . #2=(|SCENE;createPlot1Din3Dparametric;MSNni$;74|))
          (LETT |tRange| (|SCENE;normalize| |seg| $) . #2#)
          (|SCENE;checkRange| |tRange| $)
          (LETT |l| (SPADCALL |tRange| (QREFELT $ 85)) . #2#)
          (LETT |h| (SPADCALL |tRange| (QREFELT $ 86)) . #2#)
          (LETT |t| (SPADCALL |l| (QREFELT $ 151)) . #2#)
          (LETT |p| (SPADCALL (SPADCALL |l| |f|) (QREFELT $ 152)) . #2#)
          (LETT |s|
                (DIV-DF (SUB-DF |h| |l|)
                        (FLOAT (- |numPts| 1) MOST-POSITIVE-DOUBLE-FLOAT))
                . #2#)
          (SEQ (LETT |i| 2 . #2#) (LETT #1# (- |numPts| 1) . #2#) G190
               (COND ((QSGREATERP |i| #1#) (GO G191)))
               (SEQ (LETT |l| (ADD-DF |l| |s|) . #2#)
                    (LETT |t| (CONS |l| |t|) . #2#)
                    (EXIT (LETT |p| (CONS (SPADCALL |l| |f|) |p|) . #2#)))
               (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191 (EXIT NIL))
          (LETT |t| (NREVERSE (CONS |h| |t|)) . #2#)
          (LETT |p| (NREVERSE (CONS (SPADCALL |h| |f|) |p|)) . #2#)
          (EXIT (SPADCALL |p| (QREFELT $ 19))))))) 

(DEFUN |SCENE;addPlot1Din3Dparametric;$MSNni$;75| (|n| |psc| |seg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |psc| |seg| |numPts| (QREFELT $ 168))
            |SCENE;addPlot1Din3Dparametric;$MSNni$;75|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot2Din3D;M2SNni$;76| (|ptFun| |uSeg| |vSeg| |numPts| $)
  (PROG (|someV| |llp| |someU| |lp| |pt| |iu| |iv| |vstep| |ustep|)
    (RETURN
     (SEQ (LETT |llp| NIL . #1=(|SCENE;createPlot2Din3D;M2SNni$;76|))
          (LETT |ustep|
                (DIV-DF-I
                 (SUB-DF (SPADCALL |uSeg| (QREFELT $ 85))
                         (SPADCALL |uSeg| (QREFELT $ 86)))
                 |numPts|)
                . #1#)
          (LETT |vstep|
                (DIV-DF-I
                 (SUB-DF (SPADCALL |vSeg| (QREFELT $ 85))
                         (SPADCALL |vSeg| (QREFELT $ 86)))
                 |numPts|)
                . #1#)
          (LETT |someV| (SPADCALL |vSeg| (QREFELT $ 86)) . #1#)
          (SEQ (LETT |iv| |numPts| . #1#) G190 (COND ((< |iv| 0) #2=(GO G191)))
               (SEQ
                (COND
                 ((ZEROP |iv|)
                  (LETT |someV| (SPADCALL |vSeg| (QREFELT $ 85)) . #1#)))
                (LETT |lp| NIL . #1#)
                (LETT |someU| (SPADCALL |uSeg| (QREFELT $ 86)) . #1#)
                (SEQ (LETT |iu| |numPts| . #1#) G190 (COND ((< |iu| 0) #2#))
                     (SEQ
                      (COND
                       ((ZEROP |iu|)
                        (LETT |someU| (SPADCALL |uSeg| (QREFELT $ 85)) . #1#)))
                      (LETT |pt| (SPADCALL |someU| |someV| |ptFun|) . #1#)
                      (LETT |lp| (CONS |pt| |lp|) . #1#)
                      (EXIT (LETT |someU| (ADD-DF |someU| |ustep|) . #1#)))
                     (LETT |iu| (+ |iu| -1) . #1#) #3=(GO G190) G191
                     (EXIT NIL))
                (LETT |llp| (CONS |lp| |llp|) . #1#)
                (EXIT (LETT |someV| (ADD-DF |someV| |vstep|) . #1#)))
               (LETT |iv| (+ |iv| -1) . #1#) #3# G191 (EXIT NIL))
          (EXIT
           (SPADCALL (SPADCALL |llp| 'NIL (QREFELT $ 122)) (QREFELT $ 33))))))) 

(DEFUN |SCENE;createPlot2Din3D;M2SNni$;77| (|f| |xSeg| |ySeg| |numPts| $)
  (PROG (|fcn|)
    (RETURN
     (SEQ
      (LETT |fcn|
            (LIST
             (CONS #'|SCENE;createPlot2Din3D;M2SNni$;77!0| (VECTOR $ |f|)))
            |SCENE;createPlot2Din3D;M2SNni$;77|)
      (EXIT
       (SPADCALL (SPADCALL |fcn| (QREFELT $ 175)) (|SCENE;normalize| |xSeg| $)
                 (|SCENE;normalize| |ySeg| $) |numPts| (QREFELT $ 173))))))) 

(DEFUN |SCENE;createPlot2Din3D;M2SNni$;77!0| (|x| |y| $$)
  (PROG (|f| $)
    (LETT |f| (QREFELT $$ 1) . #1=(|SCENE;createPlot2Din3D;M2SNni$;77|))
    (LETT $ (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|SCENE;applyfxyTrap| |f| |x| |y| $) |x| |y| (QREFELT $ 36)))))) 

(DEFUN |SCENE;addPlot2Din3D;$M2SNni$;78| (|n| |f| |xSeg| |ySeg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |f| |xSeg| |ySeg| |numPts| (QREFELT $ 177))
            |SCENE;addPlot2Din3D;$M2SNni$;78|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot2Din3Dparametric;Ps2SNni$;79|
       (|s| |uSeg| |vSeg| |numPts| $)
  (PROG (|fcn| |h| |g| |f|)
    (RETURN
     (SEQ
      (LETT |f| (LIST (SPADCALL |s| (|spadConstant| $ 180) (QREFELT $ 182)))
            . #1=(|SCENE;createPlot2Din3Dparametric;Ps2SNni$;79|))
      (LETT |g| (LIST (SPADCALL |s| 2 (QREFELT $ 182))) . #1#)
      (LETT |h| (LIST (SPADCALL |s| 3 (QREFELT $ 182))) . #1#)
      (LETT |fcn|
            (LIST
             (CONS #'|SCENE;createPlot2Din3Dparametric;Ps2SNni$;79!0|
                   (VECTOR |h| |g| $ |f|)))
            . #1#)
      (EXIT
       (SPADCALL (SPADCALL |fcn| (QREFELT $ 175)) (|SCENE;normalize| |uSeg| $)
                 (|SCENE;normalize| |vSeg| $) |numPts| (QREFELT $ 173))))))) 

(DEFUN |SCENE;createPlot2Din3Dparametric;Ps2SNni$;79!0| (|x| |y| $$)
  (PROG (|f| $ |g| |h|)
    (LETT |f| (QREFELT $$ 3)
          . #1=(|SCENE;createPlot2Din3Dparametric;Ps2SNni$;79|))
    (LETT $ (QREFELT $$ 2) . #1#)
    (LETT |g| (QREFELT $$ 1) . #1#)
    (LETT |h| (QREFELT $$ 0) . #1#)
    (RETURN
     (PROGN
      (SPADCALL (|SCENE;applyfxyTrap| (SPADCALL |f| (QREFELT $ 184)) |x| |y| $)
                (|SCENE;applyfxyTrap| (SPADCALL |g| (QREFELT $ 184)) |x| |y| $)
                (|SCENE;applyfxyTrap| (SPADCALL |h| (QREFELT $ 184)) |x| |y| $)
                (QREFELT $ 36)))))) 

(DEFUN |SCENE;addPlot2Din3Dparametric;$Ps2SNni$;80|
       (|n| |s| |uSeg| |vSeg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |s| |uSeg| |vSeg| |numPts| (QREFELT $ 185))
            |SCENE;addPlot2Din3Dparametric;$Ps2SNni$;80|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;createPlot2Din3Dparametric;M2SNni$;81|
       (|s| |uSeg| |vSeg| |numPts| $)
  (PROG (|fcn|)
    (RETURN
     (SEQ (LETT |fcn| (LIST |s|) |SCENE;createPlot2Din3Dparametric;M2SNni$;81|)
          (EXIT
           (SPADCALL (SPADCALL |fcn| (QREFELT $ 175))
                     (|SCENE;normalize| |uSeg| $) (|SCENE;normalize| |vSeg| $)
                     |numPts| (QREFELT $ 173))))))) 

(DEFUN |SCENE;addPlot2Din3Dparametric;$M2SNni$;82|
       (|n| |s| |uSeg| |vSeg| |numPts| $)
  (PROG (|c|)
    (RETURN
     (SEQ
      (LETT |c| (SPADCALL |s| |uSeg| |vSeg| |numPts| (QREFELT $ 187))
            |SCENE;addPlot2Din3Dparametric;$M2SNni$;82|)
      (SPADCALL |n| |c| (QREFELT $ 16)) (EXIT |c|))))) 

(DEFUN |SCENE;coerce;$Of;83| (|n| $)
  (PROG (|s|)
    (RETURN
     (SEQ (LETT |s| "scene " . #1=(|SCENE;coerce;$Of;83|))
          (COND ((EQL (QVELT |n| 0) 1) (LETT |s| (STRCONC |s| "root") . #1#)))
          (COND ((EQL (QVELT |n| 0) 2) (LETT |s| (STRCONC |s| "group") . #1#)))
          (COND ((EQL (QVELT |n| 0) 3) (LETT |s| (STRCONC |s| "line") . #1#)))
          (COND
           ((EQL (QVELT |n| 0) 4) (LETT |s| (STRCONC |s| "material") . #1#)))
          (COND ((EQL (QVELT |n| 0) 5) (LETT |s| (STRCONC |s| "text") . #1#)))
          (COND
           ((EQL (QVELT |n| 0) 6) (LETT |s| (STRCONC |s| "transform") . #1#)))
          (COND ((EQL (QVELT |n| 0) 7) (LETT |s| (STRCONC |s| "clip") . #1#)))
          (COND ((EQL (QVELT |n| 0) 8) (LETT |s| (STRCONC |s| "ifs") . #1#)))
          (COND ((EQL (QVELT |n| 0) 9) (LETT |s| (STRCONC |s| "arrow") . #1#)))
          (LETT |s|
                (SPADCALL
                 (LIST |s| " #ch="
                       (STRINGIMAGE (SPADCALL (QVELT |n| 1) (QREFELT $ 109))))
                 (QREFELT $ 75))
                . #1#)
          (EXIT (SPADCALL |s| (QREFELT $ 190))))))) 

(DEFUN |Scene| (#1=#:G2593)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2594)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache| '|Scene|)
                                           '|domainEqualList|)
                . #3=(|Scene|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|Scene;| #1#) (LETT #2# T . #3#))
            (COND ((NOT #2#) (HREM |$ConstructorCache| '|Scene|))))))))))) 

(DEFUN |Scene;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|Scene|))
      (LETT |dv$| (LIST '|Scene| DV$1) . #1#)
      (LETT $ (GETREFV 192) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|Scene| (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      (QSETREFV $ 7
                (|Record| (|:| |type| (|NonNegativeInteger|))
                          (|:| |children| (|List| $))
                          (|:| |parameters|
                               (|Union| (|:| |points| (|List| (|List| |#1|)))
                                        (|:| |material|
                                             (|Record|
                                              (|:| |lineWidth| (|DoubleFloat|))
                                              (|:| |lineCol| (|String|))
                                              (|:| |fillCol| (|String|))
                                              (|:| |matOpacity|
                                                   (|DoubleFloat|))))
                                        (|:| |text|
                                             (|Record| (|:| |txt| (|String|))
                                                       (|:| |siz|
                                                            (|NonNegativeInteger|))
                                                       (|:| |pos| |#1|)))
                                        (|:| |boundbox|
                                             (|Record| (|:| |mins| |#1|)
                                                       (|:| |maxs| |#1|)))
                                        (|:| |trans| (|STransform| |#1|))
                                        (|:| |ifs|
                                             (|Record|
                                              (|:| |inx|
                                                   (|List|
                                                    (|List|
                                                     (|NonNegativeInteger|))))
                                              (|:| |pts| (|List| |#1|))))
                                        (|:| |arrws|
                                             (|Record|
                                              (|:| |ln| (|List| (|List| |#1|)))
                                              (|:| |lstart|
                                                   (|NonNegativeInteger|))
                                              (|:| |lend|
                                                   (|NonNegativeInteger|))))
                                        (|:| |empty| "empty")))))
      $)))) 

(MAKEPROP '|Scene| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep|
              (|Record| (|:| |mins| 6) (|:| |maxs| 6))
              |SCENE;createSceneRoot;R$;1| (|Integer|) (0 . |sipnt|)
              |SCENE;createSceneRoot;4I$;2| |SCENE;createSceneRoot;$;3|
              |SCENE;createSceneGroup;$;4| (|Void|) |SCENE;addChild!;2$V;44|
              |SCENE;addSceneGroup;2$;5| (|List| 6)
              |SCENE;createSceneLine;L$;6| |SCENE;addSceneLine;$L$;7|
              (|List| 18) |SCENE;createSceneLines;L$;8|
              |SCENE;addSceneLines;$L$;9| (|NonNegativeInteger|)
              |SCENE;createSceneArrows;L2Nni$;10|
              |SCENE;addSceneArrows;$L2Nni$;11| (|List| 66)
              |SCENE;createSceneIFS;LL$;12| |SCENE;addSceneIFS;$LL$;13|
              (|SceneIFS| 6) (6 . |indexes|) (11 . |pointList|)
              |SCENE;createSceneIFS;Sifs$;14| |SCENE;addSceneIFS;$Sifs$;15|
              (|DoubleFloat|) (16 . |spnt|) |SCENE;createSceneBox;Df$;16|
              |SCENE;addSceneBox;$Df$;17|
              (|Record| (|:| |txt| 42) (|:| |siz| 24) (|:| |pos| 6))
              |SCENE;createSceneText;R$;18| |SCENE;addSceneText;$R$;19|
              (|String|) |SCENE;createSceneText;SNniPT$;20|
              |SCENE;addSceneText;$SNniPT$;21| |SCENE;createSceneClip;R$;22|
              |SCENE;addSceneClip;$R$;23| (23 . |screenCoordX|)
              (28 . |screenCoordY|) (33 . |spnt|)
              |SCENE;createSceneGrid;DfR$;24| |SCENE;addSceneGrid;$DfR$;25|
              (|PositiveInteger|) (|Float|) (39 . |float|) (46 . |coerce|)
              (|Record| (|:| |lineWidth| 35) (|:| |lineCol| 42)
                        (|:| |fillCol| 42) (|:| |matOpacity| 35))
              |SCENE;addSceneMaterial;$R$;37| |SCENE;createSceneGrid;R$;26|
              |SCENE;addSceneGrid;$R$;27| (51 . |singleFace|)
              (56 . |sierpinskiDivide|) (62 . |elt|) (68 . +) (74 . *)
              (80 . |concat|) (|List| 24) (86 . |elt|) (92 . |#|) (97 . |elt|)
              (103 . |concat|) |SCENE;createScenePattern;2NniR$;32|
              |SCENE;addScenePattern;$2NniR$;33| (109 . |log10|) (|List| $)
              (114 . |concat|) |SCENE;createSceneRuler;NniPTR$;34|
              |SCENE;addSceneRuler;$NniPTR$;35|
              |SCENE;createSceneMaterial;R$;36|
              |SCENE;createSceneMaterial;Df2S$;38|
              |SCENE;addSceneMaterial;$Df2S$;39| (|STransform| 6)
              |SCENE;createSceneTransform;St$;40|
              |SCENE;addSceneTransform;$St$;41| (|Segment| 35) (119 . |lo|)
              (124 . |hi|) (|Mapping| 6 6)
              |SCENE;createArrows2Din2D;M2SNni$;42|
              |SCENE;addArrows2Din2D;$M2SNni$;43| (|List| $$) (129 . |concat|)
              |SCENE;removeChild!;2$V;45| |SCENE;setTransform!;$StV;46|
              (135 . |xform|) (|Boolean|) (141 . |inBounds?|)
              (148 . |distance|) (|XmlAttribute|) (154 . |xmlAttribute|)
              (|List| 98) (|XmlElement|) (160 . |xmlElement|) (|List| 101)
              (167 . |concat|) (173 . |stranslate|) (183 . |concat|)
              (189 . |xmlElement|) (196 . |compound|) (202 . |#|)
              |SCENE;toSVG;$RStRDf2BXe;50| (207 . |empty?|) (212 . |identity|)
              (|ExportXml|) (216 . |writeXml|) |SCENE;writeSvg;$SV;51|
              |SCENE;writeSvgQuantised;$SV;52| (222 . |screenCoordZ|)
              (|List| 42) (227 . |concat|) |SCENE;toX3D;$RStRXe;56|
              (233 . |curveLoops|) (240 . |smesh|) (246 . |xmlAttribute|)
              |SCENE;writeX3d;$SV;57| (|Reference| 18) (|Reference| 27)
              (|Reference| 24) |SCENE;toObj;$RRRStRV;58| (252 . |elt|)
              (257 . |elt|) (262 . |concat|) (268 . |setelt|) (274 . |elt|)
              (279 . |concat|) (285 . |setelt|) (291 . |setelt|) (297 . |ref|)
              (302 . |ref|) (307 . |ref|) (|FileName|) (312 . |coerce|)
              (|TextFile|) (317 . |open|) (323 . |writeLine!|) (329 . |close!|)
              |SCENE;writeObj;$SV;59| (334 . |writeVRML|)
              |SCENE;writeVRML;$SV;60| (340 . |segment|) (|List| 35)
              (346 . |list|) (351 . |list|) (356 . |Pnan?|) (|Mapping| 6 35)
              |SCENE;createPlot1Din2D;MSNni$;66|
              |SCENE;addPlot1Din2D;$MSNni$;67| (|List| 154) (361 . |first|)
              (|Mapping| 35 35) |SCENE;createPlot1Din2D;MSNni$;68|
              |SCENE;addPlot1Din2D;$MSNni$;69| (|ParametricPlaneCurve| 159)
              (366 . |coordinate|)
              |SCENE;createPlot1Din2Dparametric;PpcSNni$;70|
              |SCENE;addPlot1Din2Dparametric;$PpcSNni$;71|
              (|ParametricSpaceCurve| 159) (372 . |coordinate|)
              |SCENE;createPlot1Din3Dparametric;MSNni$;74|
              |SCENE;createPlot1Din3Dparametric;PscSNni$;72|
              |SCENE;addPlot1Din3Dparametric;$PscSNni$;73|
              |SCENE;addPlot1Din3Dparametric;$MSNni$;75| (|Mapping| 6 35 35)
              |SCENE;createPlot2Din3D;M2SNni$;76| (|List| 172) (378 . |first|)
              (|Mapping| 35 35 35) |SCENE;createPlot2Din3D;M2SNni$;77|
              |SCENE;addPlot2Din3D;$M2SNni$;78| (383 . |One|) (387 . |One|)
              (|ParametricSurface| 176) (391 . |coordinate|) (|List| 176)
              (397 . |first|) |SCENE;createPlot2Din3Dparametric;Ps2SNni$;79|
              |SCENE;addPlot2Din3Dparametric;$Ps2SNni$;80|
              |SCENE;createPlot2Din3Dparametric;M2SNni$;81|
              |SCENE;addPlot2Din3Dparametric;$M2SNni$;82| (|OutputForm|)
              (402 . |coerce|) |SCENE;coerce;$Of;83|)
           '#(|writeX3d| 407 |writeVRML| 413 |writeSvgQuantised| 419 |writeSvg|
              425 |writeObj| 431 |toX3D| 437 |toSVG| 445 |toObj| 456
              |setTransform!| 466 |removeChild!| 472 |createSceneTransform| 478
              |createSceneText| 483 |createSceneRuler| 495 |createSceneRoot|
              502 |createScenePattern| 519 |createSceneMaterial| 526
              |createSceneLines| 538 |createSceneLine| 543 |createSceneIFS| 548
              |createSceneGroup| 559 |createSceneGrid| 563 |createSceneClip|
              574 |createSceneBox| 579 |createSceneArrows| 584
              |createPlot2Din3Dparametric| 591 |createPlot2Din3D| 607
              |createPlot1Din3Dparametric| 623 |createPlot1Din2Dparametric| 637
              |createPlot1Din2D| 644 |createArrows2Din2D| 658 |coerce| 666
              |addSceneTransform| 671 |addSceneText| 677 |addSceneRuler| 691
              |addScenePattern| 699 |addSceneMaterial| 707 |addSceneLines| 721
              |addSceneLine| 727 |addSceneIFS| 733 |addSceneGroup| 746
              |addSceneGrid| 751 |addSceneClip| 764 |addSceneBox| 770
              |addSceneArrows| 776 |addPlot2Din3Dparametric| 784
              |addPlot2Din3D| 802 |addPlot1Din3Dparametric| 811
              |addPlot1Din2Dparametric| 827 |addPlot1Din2D| 835 |addChild!| 851
              |addArrows2Din2D| 857)
           'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 191
                                                 '(2 6 0 10 10 11 1 30 27 0 31
                                                   1 30 18 0 32 3 6 0 35 35 35
                                                   36 1 6 35 0 47 1 6 35 0 48 2
                                                   6 0 35 35 49 3 53 0 10 10 52
                                                   54 1 53 35 0 55 1 30 0 18 60
                                                   2 30 0 0 24 61 2 18 6 0 10
                                                   62 2 6 0 0 0 63 2 6 0 35 0
                                                   64 2 18 0 0 6 65 2 27 66 0
                                                   10 67 1 66 24 0 68 2 66 24 0
                                                   10 69 2 21 0 0 18 70 1 35 0
                                                   0 73 1 42 0 74 75 1 84 35 0
                                                   85 1 84 35 0 86 2 90 0 0 2
                                                   91 2 81 6 0 6 94 3 6 95 0 0
                                                   0 96 2 6 35 0 0 97 2 98 0 42
                                                   42 99 3 101 0 42 74 100 102
                                                   2 103 0 0 101 104 6 81 0 35
                                                   35 35 35 35 35 105 2 100 0 0
                                                   98 106 3 101 0 42 42 100 107
                                                   2 81 0 0 0 108 1 90 24 0 109
                                                   1 101 95 0 111 0 81 0 112 2
                                                   113 15 101 42 114 1 6 35 0
                                                   117 2 118 0 0 42 119 3 30 21
                                                   18 35 10 121 2 30 0 21 95
                                                   122 2 98 0 42 118 123 1 127
                                                   24 0 129 1 125 18 0 130 2 18
                                                   0 0 0 131 2 125 18 0 18 132
                                                   1 126 27 0 133 2 27 0 0 0
                                                   134 2 126 27 0 27 135 2 127
                                                   24 0 24 136 1 125 0 18 137 1
                                                   126 0 27 138 1 127 0 24 139
                                                   1 140 0 42 141 2 142 0 140
                                                   42 143 2 142 42 0 42 144 1
                                                   142 0 0 145 2 113 15 101 42
                                                   147 2 84 0 35 35 149 1 150 0
                                                   35 151 1 18 0 6 152 1 6 95 0
                                                   153 1 157 154 0 158 2 162
                                                   159 0 24 163 2 166 159 0 24
                                                   167 1 174 172 0 175 0 35 0
                                                   179 0 24 0 180 2 181 176 0
                                                   24 182 1 183 176 0 184 1 42
                                                   189 0 190 2 0 15 0 42 124 2
                                                   0 15 0 42 148 2 0 15 0 42
                                                   116 2 0 15 0 42 115 2 0 15 0
                                                   42 146 4 0 101 0 56 81 8 120
                                                   7 0 101 0 56 81 8 35 95 95
                                                   110 6 0 15 0 125 126 127 81
                                                   8 128 2 0 15 0 81 93 2 0 15
                                                   0 0 92 1 0 0 81 82 1 0 0 39
                                                   40 3 0 0 42 24 6 43 3 0 0 24
                                                   6 8 76 1 0 0 8 9 0 0 0 13 4
                                                   0 0 10 10 10 10 12 3 0 0 24
                                                   24 8 71 1 0 0 56 78 3 0 0 35
                                                   42 42 79 1 0 0 21 22 1 0 0
                                                   18 19 2 0 0 27 18 28 1 0 0
                                                   30 33 0 0 0 14 2 0 0 35 8 50
                                                   1 0 0 8 58 1 0 0 8 45 1 0 0
                                                   35 37 3 0 0 21 24 24 25 4 0
                                                   0 172 84 84 24 187 4 0 0 181
                                                   84 84 24 185 4 0 0 172 84 84
                                                   24 173 4 0 0 176 84 84 24
                                                   177 3 0 0 166 84 24 169 3 0
                                                   0 154 84 24 168 3 0 0 162 84
                                                   24 164 3 0 0 154 84 24 155 3
                                                   0 0 159 84 24 160 4 0 0 87
                                                   84 84 24 88 1 0 189 0 191 2
                                                   0 0 0 81 83 2 0 0 0 39 41 4
                                                   0 0 0 42 24 6 44 4 0 0 0 24
                                                   6 8 77 4 0 0 0 24 24 8 72 2
                                                   0 0 0 56 57 4 0 0 0 35 42 42
                                                   80 2 0 0 0 21 23 2 0 0 0 18
                                                   20 3 0 0 0 27 18 29 2 0 0 0
                                                   30 34 1 0 0 0 17 3 0 0 0 35
                                                   8 51 2 0 0 0 8 59 2 0 0 0 8
                                                   46 2 0 0 0 35 38 4 0 0 0 21
                                                   24 24 26 5 0 0 0 172 84 84
                                                   24 188 5 0 0 0 181 84 84 24
                                                   186 5 0 0 0 176 84 84 24 178
                                                   4 0 0 0 166 84 24 170 4 0 0
                                                   0 154 84 24 171 4 0 0 0 162
                                                   84 24 165 4 0 0 0 154 84 24
                                                   156 4 0 0 0 159 84 24 161 2
                                                   0 15 0 0 16 5 0 0 0 87 84 84
                                                   24 89)))))
           '|lookupComplete|)) 
