
(/VERSIONCHECK 2) 

(DEFUN |DRAWPT;draw;LLTdv;1| (|lp| |l| $)
  (SPADCALL (SPADCALL (LIST |lp|) (QREFELT $ 8)) |l| (QREFELT $ 11))) 

(DEFUN |DRAWPT;draw;LTdv;2| (|lp| $) (SPADCALL |lp| NIL (QREFELT $ 13))) 

(DEFUN |DRAWPT;draw;2LLTdv;3| (|lx| |ly| |l| $)
  (PROG (#1=#:G1808 |x| #2=#:G1809 |y| #3=#:G1807)
    (RETURN
     (SEQ
      (SPADCALL
       (PROGN
        (LETT #3# NIL . #4=(|DRAWPT;draw;2LLTdv;3|))
        (SEQ (LETT |y| NIL . #4#) (LETT #2# |ly| . #4#) (LETT |x| NIL . #4#)
             (LETT #1# |lx| . #4#) G190
             (COND
              ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #4#) NIL) (ATOM #2#)
                   (PROGN (LETT |y| (CAR #2#) . #4#) NIL))
               (GO G191)))
             (SEQ
              (EXIT
               (LETT #3# (CONS (SPADCALL (LIST |x| |y|) (QREFELT $ 17)) #3#)
                     . #4#)))
             (LETT #1# (PROG1 (CDR #1#) (LETT #2# (CDR #2#) . #4#)) . #4#)
             (GO G190) G191 (EXIT (NREVERSE0 #3#))))
       |l| (QREFELT $ 13)))))) 

(DEFUN |DRAWPT;draw;2LTdv;4| (|lx| |ly| $)
  (SPADCALL |lx| |ly| NIL (QREFELT $ 18))) 

(DEFUN |DRAWPT;draw;3LTdv;5| (|x| |y| |z| $)
  (SPADCALL |x| |y| |z| NIL (QREFELT $ 21))) 

(DEFUN |DRAWPT;draw;3LLTdv;6| (|x| |y| |z| |l| $)
  (PROG (|points| |row| |zval| |i| |j| |zLen| |n| |m|)
    (RETURN
     (SEQ (LETT |m| (LENGTH |x|) . #1=(|DRAWPT;draw;3LLTdv;6|))
          (EXIT
           (COND ((ZEROP |m|) (|error| "No X values"))
                 (#2='T
                  (SEQ (LETT |n| (LENGTH |y|) . #1#)
                       (EXIT
                        (COND ((ZEROP |n|) (|error| "No Y values"))
                              (#2#
                               (SEQ (LETT |zLen| (LENGTH |z|) . #1#)
                                    (COND
                                     ((NULL (EQL |zLen| (* |m| |n|)))
                                      (EXIT
                                       (COND
                                        ((< (* |m| |n|) |zLen|)
                                         (|error|
                                          "Too many Z-values to fit grid"))
                                        (#2#
                                         (|error|
                                          "Not enough Z-values to fit grid"))))))
                                    (LETT |points| NIL . #1#)
                                    (SEQ (LETT |j| |n| . #1#) G190
                                         (COND ((< |j| 1) #3=(GO G191)))
                                         (SEQ (LETT |row| NIL . #1#)
                                              (SEQ (LETT |i| |m| . #1#) G190
                                                   (COND ((< |i| 1) #3#))
                                                   (SEQ
                                                    (LETT |zval|
                                                          (+ (* (- |j| 1) |m|)
                                                             |i|)
                                                          . #1#)
                                                    (EXIT
                                                     (LETT |row|
                                                           (CONS
                                                            (SPADCALL
                                                             (LIST
                                                              (SPADCALL |x| |i|
                                                                        (QREFELT
                                                                         $ 25))
                                                              (SPADCALL |y| |j|
                                                                        (QREFELT
                                                                         $ 25))
                                                              (SPADCALL |z|
                                                                        |zval|
                                                                        (QREFELT
                                                                         $ 25))
                                                              (SPADCALL |z|
                                                                        |zval|
                                                                        (QREFELT
                                                                         $
                                                                         25)))
                                                             (QREFELT $ 17))
                                                            |row|)
                                                           . #1#)))
                                                   (LETT |i| (+ |i| -1) . #1#)
                                                   #4=(GO G190) G191
                                                   (EXIT NIL))
                                              (EXIT
                                               (LETT |points|
                                                     (CONS |row| |points|)
                                                     . #1#)))
                                         (LETT |j| (+ |j| -1) . #1#) #4# G191
                                         (EXIT NIL))
                                    (EXIT
                                     (SPADCALL
                                      (SPADCALL |points| (QREFELT $ 27)) |l|
                                      (QREFELT $ 28))))))))))))))) 

(DEFUN |TopLevelDrawFunctionsForPoints| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G1840)
       (RETURN
        (COND
         ((LETT #2#
                (HGET |$ConstructorCache| '|TopLevelDrawFunctionsForPoints|)
                . #3=(|TopLevelDrawFunctionsForPoints|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|TopLevelDrawFunctionsForPoints|
                         (LIST
                          (CONS NIL
                                (CONS 1
                                      (|TopLevelDrawFunctionsForPoints;|))))))
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache|
                    '|TopLevelDrawFunctionsForPoints|))))))))))) 

(DEFUN |TopLevelDrawFunctionsForPoints;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|TopLevelDrawFunctionsForPoints|)
            . #1=(|TopLevelDrawFunctionsForPoints|))
      (LETT $ (GETREFV 29) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|TopLevelDrawFunctionsForPoints| NIL
                  (CONS 1 $))
      (|stuffDomainSlots| $)
      $)))) 

(MAKEPROP '|TopLevelDrawFunctionsForPoints| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|List| 12) (|GraphImage|)
              (0 . |makeGraphImage|) (|List| (|DrawOption|))
              (|TwoDimensionalViewport|) (5 . |makeViewport2D|) (|List| 16)
              |DRAWPT;draw;LLTdv;1| |DRAWPT;draw;LTdv;2| (|List| 23)
              (|Point| 23) (11 . |point|) |DRAWPT;draw;2LLTdv;3|
              |DRAWPT;draw;2LTdv;4| (|ThreeDimensionalViewport|)
              |DRAWPT;draw;3LLTdv;6| |DRAWPT;draw;3LTdv;5| (|DoubleFloat|)
              (|Integer|) (16 . |elt|) (|ThreeSpace| 23) (22 . |mesh|)
              (27 . |makeViewport3D|))
           '#(|draw| 33) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 28
                                                 '(1 7 0 6 8 2 10 0 7 9 11 1 16
                                                   0 15 17 2 15 23 0 24 25 1 26
                                                   0 6 27 2 20 0 26 9 28 2 0 10
                                                   15 15 19 1 0 10 12 14 3 0 10
                                                   15 15 9 18 2 0 10 12 9 13 4
                                                   0 20 15 15 15 9 21 3 0 20 15
                                                   15 15 22)))))
           '|lookupComplete|)) 

(MAKEPROP '|TopLevelDrawFunctionsForPoints| 'NILADIC T) 
