
(/VERSIONCHECK 2) 

(DEFUN |SEG2;map;MSS;1| (|f| |r| $)
  (SPADCALL (SPADCALL (SPADCALL |r| (QREFELT $ 9)) |f|)
      (SPADCALL (SPADCALL |r| (QREFELT $ 10)) |f|) (QREFELT $ 12))) 

(DEFUN |SEG2;map;MSL;2| (|f| |r| $)
  (PROG (|h| |inc| |lr| |l|)
    (RETURN
      (SEQ (LETT |lr| NIL . #0=(|SEG2;map;MSL;2|))
           (LETT |l| (SPADCALL |r| (QREFELT $ 9)) . #0#)
           (LETT |h| (SPADCALL |r| (QREFELT $ 10)) . #0#)
           (LETT |inc|
                 (SPADCALL (SPADCALL |r| (QREFELT $ 16))
                     (QREFELT $ 17)) . #0#)
           (COND
             ((SPADCALL (|spadConstant| $ 18) |inc| (QREFELT $ 20))
              (SEQ G190
                   (COND
                     ((NULL (COND
                              ((SPADCALL |h| |l| (QREFELT $ 20)) 'NIL)
                              ('T 'T)))
                      #1=(GO G191)))
                   (SEQ (LETT |lr|
                              (CONS (SPADCALL |l| |f|) |lr|) . #0#)
                        (EXIT (LETT |l|
                                    (SPADCALL |l| |inc| (QREFELT $ 21)) . #0#)))
                   NIL #2=(GO G190) G191 (EXIT NIL)))
             ('T
              (SEQ G190
                   (COND
                     ((NULL (COND
                              ((SPADCALL |l| |h| (QREFELT $ 20)) 'NIL)
                              ('T 'T)))
                      #1#))
                   (SEQ (LETT |lr|
                              (CONS (SPADCALL |l| |f|) |lr|) . #0#)
                        (EXIT (LETT |l|
                                    (SPADCALL |l| |inc| (QREFELT $ 21)) . #0#)))
                   NIL #2# G191 (EXIT NIL))))
           (EXIT (NREVERSE |lr|)))))) 

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

(DEFUN |SegmentFunctions2;| (|#1| |#2|)
  (PROG (DV$1 DV$2 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|SegmentFunctions2|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT |dv$| (LIST '|SegmentFunctions2| DV$1 DV$2) . #0#)
        (LETT $ (GETREFV 24) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1| '(|OrderedRing|)))) . #0#))
        (|haddProp| |$ConstructorCache| '|SegmentFunctions2|
            (LIST DV$1 DV$2) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (COND
          ((|testBitVector| |pv$| 1)
           (QSETREFV $ 23
               (CONS (|dispatchFunction| |SEG2;map;MSL;2|) $))))
        $)))) 

(MAKEPROP '|SegmentFunctions2| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|Segment| 6) (0 . |lo|) (5 . |hi|) (|Segment| 7)
             (10 . SEGMENT) (|Mapping| 7 6) |SEG2;map;MSS;1|
             (|Integer|) (16 . |incr|) (21 . |coerce|) (26 . |Zero|)
             (|Boolean|) (30 . <) (36 . +) (|List| 7) (42 . |map|))
          '#(|map| 48) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 23
                                '(1 8 6 0 9 1 8 6 0 10 2 11 0 7 7 12 1
                                  8 15 0 16 1 6 0 15 17 0 6 0 18 2 6 19
                                  0 0 20 2 6 0 0 0 21 2 0 22 13 8 23 2
                                  1 22 13 8 23 2 0 11 13 8 14)))))
          '|lookupComplete|)) 
