if I leave a (declare (optimize (debug 2) (speed 0) (space 0))) in redisplay-output-record (in incremental-redisplay.lisp), this happens when compiling on 0.9.16:


; compiling file "/Users/asf/dl/cvs/mcclim/incremental-redisplay.lisp" (written 25 SEP 2006 02:59:47 AM):
unhandled SIMPLE-ERROR in thread #<SB-THREAD:THREAD "initial thread" {118C5509}>:
  Error during processing of --eval option "(progn (require :mcclim) (sb-ext:quit :unix-status 0))":

  The value 68131542 is not of type (MEMBER :SPECIAL-FORM :MACRO :FUNCTION NIL).

0: (SB-DEBUG:BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {100A04E9}>)
1: (SB-DEBUG::DEBUGGER-DISABLED-HOOK
    #<SIMPLE-ERROR {14547071}>
    #<unavailable argument>)
2: (INVOKE-DEBUGGER #<SIMPLE-ERROR {14547071}>)
3: (ERROR
    "Error during processing of --eval ~
                                    option ~S:~%~%  ~A")
4: ((LAMBDA (SB-IMPL::E)) #<TYPE-ERROR {14546FC1}>)
5: ((LAMBDA (SB-IMPL::E)) #<TYPE-ERROR {14546FC1}>)
6: (SIGNAL #<TYPE-ERROR {14546FC1}>)
7: (ERROR TYPE-ERROR)
8: (SB-KERNEL::OBJECT-NOT-TYPE-ERROR-HANDLER
    #<unavailable argument>
    #.(SB-SYS:INT-SAP #X0090361C)
    #<SB-ALIEN-INTERNALS:ALIEN-VALUE :SAP #X009035DC :TYPE (*
                                                            (SB-ALIEN:STRUCT
                                                             SB-VM::OS-CONTEXT-T-STRUCT))>
    (142 14))
9: (SB-KERNEL:INTERNAL-ERROR
    #.(SB-SYS:INT-SAP #X009035DC)
    #<unavailable argument>)
10: ("foreign function: call_into_lisp")
11: ("foreign function: funcall2")
12: ("foreign function: interrupt_internal_error")
13: ("foreign function: sigtrap_handler")
14: ("foreign function: _sigtramp")
15: (SPECIAL-OPERATOR-P SB-C::%ESCAPE-FUN)
16: (SB-C::STEP-FORM-P (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600))
17: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 1 {145404A9}>
     #<SB-C::CTRAN 2 {145406E9}>
     #<SB-C::LVAR 3 {14540701}>
     (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600))
18: (SB-C::IR1-CONVERT-COMBINATION-ARGS
     #<SB-C::LVAR 4 {145404C1}>
     #<SB-C::CTRAN 1 {145404A9}>
     #<SB-C::CTRAN 5 {14540441}>
     NIL
     ((SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
      (LOCALLY
       (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
       (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))))
19: (SB-C::IR1-CONVERT-COMBINATION
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 5 {14540441}>
     NIL
     (SB-C::%CATCH (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
      (LOCALLY
       (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
       (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME SB-C::%CATCH
       :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T T) (VALUES T &OPTIONAL))>
       :WHERE-FROM :DECLARED
       :KIND :GLOBAL-FUNCTION {14540479}>)
20: (SB-C::IR1-CONVERT-COMBINATION-CHECKING-TYPE
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 5 {14540441}>
     NIL
     (SB-C::%CATCH (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
      (LOCALLY
       (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
       (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME SB-C::%CATCH
       :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T T) (VALUES T &OPTIONAL))>
       :WHERE-FROM :DECLARED
       :KIND :GLOBAL-FUNCTION {14540479}>)
21: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 5 {14540441}>
     NIL
     (SB-C::%CATCH (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
      (LOCALLY
       (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
       (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))))
22: (SB-C::IR1-CONVERT-%WITHIN-CLEANUP
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (SB-C::%WITHIN-CLEANUP :CATCH
                            (SB-C::%CATCH (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
                             (LOCALLY
                              (DECLARE
                               (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
                              (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
                            (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                               SB-PCL::DEFAULT))
                              (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                               ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                                SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                                SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                                :NEXT-METHOD-P-P NIL :SETQ-P T
                                :METHOD-NAME-DECLARATION
                                ((REDISPLAY-OUTPUT-RECORD
                                  (UPDATING-OUTPUT-RECORD
                                   UPDATING-OUTPUT-STREAM-MIXIN)))
                                :CLOSUREP NIL :APPLYP T)
                               (DECLARE
                                (SB-PCL::%CLASS STREAM
                                 UPDATING-OUTPUT-STREAM-MIXIN))
                               (DECLARE
                                (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                               (BLOCK REDISPLAY-OUTPUT-RECORD
                                 (LETF
                                  (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                        (CURRENT-GRAPHICS-STATE
                                         (MEDIUM-GRAPHICS-STATE STREAM)))
                                    (UNWIND-PROTECT
                                        (PROGN
                                         (LETF
                                          (((DO-NOTE-OUTPUT-RECORD STREAM)
                                            NIL))
                                          (SET-MEDIUM-CURSOR-POSITION
                                           (START-GRAPHICS-STATE RECORD)
                                           STREAM)
                                          (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                           STREAM)
                                          (WHEN *DUMP-UPDATING-OUTPUT*
                                            (DUMP-UPDATING RECORD :BOTH
                                             *TRACE-OUTPUT*)))
                                         (MULTIPLE-VALUE-BIND
                                             (ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING)
                                             (COMPUTE-DIFFERENCE-SET RECORD
                                              CHECK-OVERLAPPING)
                                           (WHEN *TRACE-UPDATING-OUTPUT*
                                             (LET ((*PRINT-PRETTY* T))
                                               (FORMAT *TRACE-OUTPUT*
                                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                       ERASES MOVES DRAWS
                                                       ERASE-OVERLAPPING
                                                       MOVE-OVERLAPPING)))
                                           (INCREMENTAL-REDISPLAY STREAM NIL
                                            ERASES MOVES DRAWS
                                            ERASE-OVERLAPPING
                                            MOVE-OVERLAPPING))
                                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                      (SET-MEDIUM-CURSOR-POSITION
                                       CURRENT-GRAPHICS-STATE STREAM)))))))))
23: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (SB-C::%WITHIN-CLEANUP :CATCH
                            (SB-C::%CATCH (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
                             (LOCALLY
                              (DECLARE
                               (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
                              (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
                            (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                               SB-PCL::DEFAULT))
                              (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                               ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                                SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                                SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                                :NEXT-METHOD-P-P NIL :SETQ-P T
                                :METHOD-NAME-DECLARATION
                                ((REDISPLAY-OUTPUT-RECORD
                                  (UPDATING-OUTPUT-RECORD
                                   UPDATING-OUTPUT-STREAM-MIXIN)))
                                :CLOSUREP NIL :APPLYP T)
                               (DECLARE
                                (SB-PCL::%CLASS STREAM
                                 UPDATING-OUTPUT-STREAM-MIXIN))
                               (DECLARE
                                (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                               (BLOCK REDISPLAY-OUTPUT-RECORD
                                 (LETF
                                  (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                        (CURRENT-GRAPHICS-STATE
                                         (MEDIUM-GRAPHICS-STATE STREAM)))
                                    (UNWIND-PROTECT
                                        (PROGN
                                         (LETF
                                          (((DO-NOTE-OUTPUT-RECORD STREAM)
                                            NIL))
                                          (SET-MEDIUM-CURSOR-POSITION
                                           (START-GRAPHICS-STATE RECORD)
                                           STREAM)
                                          (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                           STREAM)
                                          (WHEN *DUMP-UPDATING-OUTPUT*
                                            (DUMP-UPDATING RECORD :BOTH
                                             *TRACE-OUTPUT*)))
                                         (MULTIPLE-VALUE-BIND
                                             (ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING)
                                             (COMPUTE-DIFFERENCE-SET RECORD
                                              CHECK-OVERLAPPING)
                                           (WHEN *TRACE-UPDATING-OUTPUT*
                                             (LET ((*PRINT-PRETTY* T))
                                               (FORMAT *TRACE-OUTPUT*
                                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                       ERASES MOVES DRAWS
                                                       ERASE-OVERLAPPING
                                                       MOVE-OVERLAPPING)))
                                           (INCREMENTAL-REDISPLAY STREAM NIL
                                            ERASES MOVES DRAWS
                                            ERASE-OVERLAPPING
                                            MOVE-OVERLAPPING))
                                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                      (SET-MEDIUM-CURSOR-POSITION
                                       CURRENT-GRAPHICS-STATE STREAM)))))))))
24: (SB-C::IR1-CONVERT-PROGN-BODY
     #<SB-C::CTRAN 6 {14540371}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     ((SB-C::%WITHIN-CLEANUP :CATCH
                             (SB-C::%CATCH
                              (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
                              (LOCALLY
                               (DECLARE
                                (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
                               (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                SB-PCL::DEFAULT))
                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                ((RECORD STREAM &OPTIONAL
                                  (CHECK-OVERLAPPING T))
                                 SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                                 SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                 :METHOD-NAME-DECLARATION
                                 ((REDISPLAY-OUTPUT-RECORD
                                   (UPDATING-OUTPUT-RECORD
                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                 :CLOSUREP NIL :APPLYP T)
                                (DECLARE
                                 (SB-PCL::%CLASS STREAM
                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                (DECLARE
                                 (SB-PCL::%CLASS RECORD
                                  UPDATING-OUTPUT-RECORD))
                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                  (LETF
                                   (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                         (CURRENT-GRAPHICS-STATE
                                          (MEDIUM-GRAPHICS-STATE STREAM)))
                                     (UNWIND-PROTECT
                                         (PROGN
                                          (LETF
                                           (((DO-NOTE-OUTPUT-RECORD STREAM)
                                             NIL))
                                           (SET-MEDIUM-CURSOR-POSITION
                                            (START-GRAPHICS-STATE RECORD)
                                            STREAM)
                                           (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                            STREAM)
                                           (WHEN *DUMP-UPDATING-OUTPUT*
                                             (DUMP-UPDATING RECORD :BOTH
                                              *TRACE-OUTPUT*)))
                                          (MULTIPLE-VALUE-BIND
                                              (ERASES MOVES DRAWS
                                               ERASE-OVERLAPPING
                                               MOVE-OVERLAPPING)
                                              (COMPUTE-DIFFERENCE-SET RECORD
                                               CHECK-OVERLAPPING)
                                            (WHEN *TRACE-UPDATING-OUTPUT*
                                              (LET ((*PRINT-PRETTY* T))
                                                (FORMAT *TRACE-OUTPUT*
                                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                        ERASES MOVES DRAWS
                                                        ERASE-OVERLAPPING
                                                        MOVE-OVERLAPPING)))
                                            (INCREMENTAL-REDISPLAY STREAM NIL
                                             ERASES MOVES DRAWS
                                             ERASE-OVERLAPPING
                                             MOVE-OVERLAPPING))
                                          (DELETE-STALE-UPDATING-OUTPUT
                                           RECORD))
                                       (SET-MEDIUM-CURSOR-POSITION
                                        CURRENT-GRAPHICS-STATE STREAM))))))))))
25: (SB-C::IR1-CONVERT-BLOCK
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (BLOCK #:EXIT-BLOCK-1600
       (SB-C::%WITHIN-CLEANUP :CATCH
                              (SB-C::%CATCH
                               (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
                               (LOCALLY
                                (DECLARE
                                 (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
                                (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                 SB-PCL::DEFAULT))
                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                 ((RECORD STREAM &OPTIONAL
                                   (CHECK-OVERLAPPING T))
                                  SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                                  SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                                  :NEXT-METHOD-P-P NIL :SETQ-P T
                                  :METHOD-NAME-DECLARATION
                                  ((REDISPLAY-OUTPUT-RECORD
                                    (UPDATING-OUTPUT-RECORD
                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                  :CLOSUREP NIL :APPLYP T)
                                 (DECLARE
                                  (SB-PCL::%CLASS STREAM
                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                 (DECLARE
                                  (SB-PCL::%CLASS RECORD
                                   UPDATING-OUTPUT-RECORD))
                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                   (LETF
                                    (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                    (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                          (CURRENT-GRAPHICS-STATE
                                           (MEDIUM-GRAPHICS-STATE STREAM)))
                                      (UNWIND-PROTECT
                                          (PROGN
                                           (LETF
                                            (((DO-NOTE-OUTPUT-RECORD STREAM)
                                              NIL))
                                            (SET-MEDIUM-CURSOR-POSITION
                                             (START-GRAPHICS-STATE RECORD)
                                             STREAM)
                                            (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                             STREAM)
                                            (WHEN *DUMP-UPDATING-OUTPUT*
                                              (DUMP-UPDATING RECORD :BOTH
                                               *TRACE-OUTPUT*)))
                                           (MULTIPLE-VALUE-BIND
                                               (ERASES MOVES DRAWS
                                                ERASE-OVERLAPPING
                                                MOVE-OVERLAPPING)
                                               (COMPUTE-DIFFERENCE-SET RECORD
                                                CHECK-OVERLAPPING)
                                             (WHEN *TRACE-UPDATING-OUTPUT*
                                               (LET ((*PRINT-PRETTY* T))
                                                 (FORMAT *TRACE-OUTPUT*
                                                         "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                         ERASES MOVES DRAWS
                                                         ERASE-OVERLAPPING
                                                         MOVE-OVERLAPPING)))
                                             (INCREMENTAL-REDISPLAY STREAM NIL
                                              ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING))
                                           (DELETE-STALE-UPDATING-OUTPUT
                                            RECORD))
                                        (SET-MEDIUM-CURSOR-POSITION
                                         CURRENT-GRAPHICS-STATE STREAM))))))))))
26: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (BLOCK #:EXIT-BLOCK-1600
       (SB-C::%WITHIN-CLEANUP :CATCH
                              (SB-C::%CATCH
                               (SB-C::%ESCAPE-FUN #:EXIT-BLOCK-1600)
                               (LOCALLY
                                (DECLARE
                                 (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
                                (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG")))
                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                 SB-PCL::DEFAULT))
                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                 ((RECORD STREAM &OPTIONAL
                                   (CHECK-OVERLAPPING T))
                                  SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                                  SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                                  :NEXT-METHOD-P-P NIL :SETQ-P T
                                  :METHOD-NAME-DECLARATION
                                  ((REDISPLAY-OUTPUT-RECORD
                                    (UPDATING-OUTPUT-RECORD
                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                  :CLOSUREP NIL :APPLYP T)
                                 (DECLARE
                                  (SB-PCL::%CLASS STREAM
                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                 (DECLARE
                                  (SB-PCL::%CLASS RECORD
                                   UPDATING-OUTPUT-RECORD))
                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                   (LETF
                                    (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                    (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                          (CURRENT-GRAPHICS-STATE
                                           (MEDIUM-GRAPHICS-STATE STREAM)))
                                      (UNWIND-PROTECT
                                          (PROGN
                                           (LETF
                                            (((DO-NOTE-OUTPUT-RECORD STREAM)
                                              NIL))
                                            (SET-MEDIUM-CURSOR-POSITION
                                             (START-GRAPHICS-STATE RECORD)
                                             STREAM)
                                            (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                             STREAM)
                                            (WHEN *DUMP-UPDATING-OUTPUT*
                                              (DUMP-UPDATING RECORD :BOTH
                                               *TRACE-OUTPUT*)))
                                           (MULTIPLE-VALUE-BIND
                                               (ERASES MOVES DRAWS
                                                ERASE-OVERLAPPING
                                                MOVE-OVERLAPPING)
                                               (COMPUTE-DIFFERENCE-SET RECORD
                                                CHECK-OVERLAPPING)
                                             (WHEN *TRACE-UPDATING-OUTPUT*
                                               (LET ((*PRINT-PRETTY* T))
                                                 (FORMAT *TRACE-OUTPUT*
                                                         "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                         ERASES MOVES DRAWS
                                                         ERASE-OVERLAPPING
                                                         MOVE-OVERLAPPING)))
                                             (INCREMENTAL-REDISPLAY STREAM NIL
                                              ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING))
                                           (DELETE-STALE-UPDATING-OUTPUT
                                            RECORD))
                                        (SET-MEDIUM-CURSOR-POSITION
                                         CURRENT-GRAPHICS-STATE STREAM))))))))))
27: (SB-C::IR1-CONVERT-CATCH
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (CATCH
         (LOCALLY
          (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
          (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
          ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
           SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
           :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
           :METHOD-NAME-DECLARATION
           ((REDISPLAY-OUTPUT-RECORD
             (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
           :CLOSUREP NIL :APPLYP T)
          (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
          (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
          (BLOCK REDISPLAY-OUTPUT-RECORD
            (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                        (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                    (UNWIND-PROTECT
                        (PROGN
                         (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                               (SET-MEDIUM-CURSOR-POSITION
                                (START-GRAPHICS-STATE RECORD) STREAM)
                               (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                               (WHEN *DUMP-UPDATING-OUTPUT*
                                 (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                         (MULTIPLE-VALUE-BIND
                             (ERASES MOVES DRAWS ERASE-OVERLAPPING
                              MOVE-OVERLAPPING)
                             (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                           (WHEN *TRACE-UPDATING-OUTPUT*
                             (LET ((*PRINT-PRETTY* T))
                               (FORMAT *TRACE-OUTPUT*
                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                       ERASES MOVES DRAWS ERASE-OVERLAPPING
                                       MOVE-OVERLAPPING)))
                           (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                            ERASE-OVERLAPPING MOVE-OVERLAPPING))
                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                      (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                       STREAM)))))))))
28: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     (CATCH
         (LOCALLY
          (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
          (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
          ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
           SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
           :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
           :METHOD-NAME-DECLARATION
           ((REDISPLAY-OUTPUT-RECORD
             (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
           :CLOSUREP NIL :APPLYP T)
          (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
          (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
          (BLOCK REDISPLAY-OUTPUT-RECORD
            (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                        (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                    (UNWIND-PROTECT
                        (PROGN
                         (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                               (SET-MEDIUM-CURSOR-POSITION
                                (START-GRAPHICS-STATE RECORD) STREAM)
                               (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                               (WHEN *DUMP-UPDATING-OUTPUT*
                                 (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                         (MULTIPLE-VALUE-BIND
                             (ERASES MOVES DRAWS ERASE-OVERLAPPING
                              MOVE-OVERLAPPING)
                             (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                           (WHEN *TRACE-UPDATING-OUTPUT*
                             (LET ((*PRINT-PRETTY* T))
                               (FORMAT *TRACE-OUTPUT*
                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                       ERASES MOVES DRAWS ERASE-OVERLAPPING
                                       MOVE-OVERLAPPING)))
                           (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                            ERASE-OVERLAPPING MOVE-OVERLAPPING))
                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                      (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                       STREAM)))))))))
29: (SB-C::IR1-CONVERT-PROGN-BODY
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     ((CATCH
          (LOCALLY
           (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
           (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM))))))))))
30: (SB-C::IR1-CONVERT-AUX-BINDINGS
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     ((CATCH
          (LOCALLY
           (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
           (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM)))))))))
     NIL
     NIL
     NIL)
31: (SB-C::IR1-CONVERT-SPECIAL-BINDINGS
     #<SB-C::CTRAN 9 {145400F9}>
     #<SB-C::CTRAN 7 {1453FF51}>
     #<SB-C::LVAR 8 {1453FF69}>
     ((CATCH
          (LOCALLY
           (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
           (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM)))))))))
     NIL
     NIL
     NIL
     NIL)
32: (SB-C::IR1-CONVERT-LAMBDA-BODY
     ((CATCH
          (LOCALLY
           (DECLARE (OPTIMIZE (SB-C:INSERT-STEP-CONDITIONS 0)))
           (SB-KERNEL:%MAKE-SYMBOL "SB-DEBUG-CATCH-TAG"))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM)))))))))
     (#<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::.PV-CELL. {1453FC19}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::.NEXT-METHOD-CALL. {1453FC69}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME RECORD {1453FCB9}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME STREAM {1453FD09}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::.REST-ARG. {1453FD59}>))
33: (SB-C::IR1-CONVERT-LAMBDA
     (LAMBDA
         (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
          SB-PCL::.REST-ARG.)
       (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
        (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
       (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
       (DECLARE
        (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
         (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
         (CHECK-OVERLAPPING T)))
       (DECLARE
        (SB-PCL::%METHOD-NAME
         (REDISPLAY-OUTPUT-RECORD
          (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
       (DECLARE (IGNORABLE STREAM RECORD))
       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
          ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
           SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
           :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
           :METHOD-NAME-DECLARATION
           ((REDISPLAY-OUTPUT-RECORD
             (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
           :CLOSUREP NIL :APPLYP T)
          (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
          (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
          (BLOCK REDISPLAY-OUTPUT-RECORD
            (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                        (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                    (UNWIND-PROTECT
                        (PROGN
                         (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                               (SET-MEDIUM-CURSOR-POSITION
                                (START-GRAPHICS-STATE RECORD) STREAM)
                               (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                               (WHEN *DUMP-UPDATING-OUTPUT*
                                 (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                         (MULTIPLE-VALUE-BIND
                             (ERASES MOVES DRAWS ERASE-OVERLAPPING
                              MOVE-OVERLAPPING)
                             (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                           (WHEN *TRACE-UPDATING-OUTPUT*
                             (LET ((*PRINT-PRETTY* T))
                               (FORMAT *TRACE-OUTPUT*
                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                       ERASES MOVES DRAWS ERASE-OVERLAPPING
                                       MOVE-OVERLAPPING)))
                           (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                            ERASE-OVERLAPPING MOVE-OVERLAPPING))
                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                      (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                       STREAM)))))))))
34: (SB-C::IR1-CONVERT-LAMBDALIKE
     (SB-INT:NAMED-LAMBDA
      (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
       (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
      (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
       SB-PCL::.REST-ARG.)
      (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
       (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
      (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
      (DECLARE
       (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
        (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL (CHECK-OVERLAPPING T)))
      (DECLARE
       (SB-PCL::%METHOD-NAME
        (REDISPLAY-OUTPUT-RECORD
         (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
      (DECLARE (IGNORABLE STREAM RECORD))
      (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
        (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
         ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
          SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
          :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
          :METHOD-NAME-DECLARATION
          ((REDISPLAY-OUTPUT-RECORD
            (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
          :CLOSUREP NIL :APPLYP T)
         (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
         (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
         (BLOCK REDISPLAY-OUTPUT-RECORD
           (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                 (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                       (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                   (UNWIND-PROTECT
                       (PROGN
                        (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                              (SET-MEDIUM-CURSOR-POSITION
                               (START-GRAPHICS-STATE RECORD) STREAM)
                              (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                              (WHEN *DUMP-UPDATING-OUTPUT*
                                (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                        (MULTIPLE-VALUE-BIND
                            (ERASES MOVES DRAWS ERASE-OVERLAPPING
                             MOVE-OVERLAPPING)
                            (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                          (WHEN *TRACE-UPDATING-OUTPUT*
                            (LET ((*PRINT-PRETTY* T))
                              (FORMAT *TRACE-OUTPUT*
                                      "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                      ERASES MOVES DRAWS ERASE-OVERLAPPING
                                      MOVE-OVERLAPPING)))
                          (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                           ERASE-OVERLAPPING MOVE-OVERLAPPING))
                        (DELETE-STALE-UPDATING-OUTPUT RECORD))
                     (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                      STREAM)))))))))
35: (SB-C::FUN-NAME-LEAF
     (SB-INT:NAMED-LAMBDA
      (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
       (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
      (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
       SB-PCL::.REST-ARG.)
      (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
       (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
      (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
      (DECLARE
       (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
        (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL (CHECK-OVERLAPPING T)))
      (DECLARE
       (SB-PCL::%METHOD-NAME
        (REDISPLAY-OUTPUT-RECORD
         (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
      (DECLARE (IGNORABLE STREAM RECORD))
      (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
        (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
         ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
          SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
          :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
          :METHOD-NAME-DECLARATION
          ((REDISPLAY-OUTPUT-RECORD
            (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
          :CLOSUREP NIL :APPLYP T)
         (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
         (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
         (BLOCK REDISPLAY-OUTPUT-RECORD
           (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                 (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                       (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                   (UNWIND-PROTECT
                       (PROGN
                        (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                              (SET-MEDIUM-CURSOR-POSITION
                               (START-GRAPHICS-STATE RECORD) STREAM)
                              (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                              (WHEN *DUMP-UPDATING-OUTPUT*
                                (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                        (MULTIPLE-VALUE-BIND
                            (ERASES MOVES DRAWS ERASE-OVERLAPPING
                             MOVE-OVERLAPPING)
                            (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                          (WHEN *TRACE-UPDATING-OUTPUT*
                            (LET ((*PRINT-PRETTY* T))
                              (FORMAT *TRACE-OUTPUT*
                                      "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                      ERASES MOVES DRAWS ERASE-OVERLAPPING
                                      MOVE-OVERLAPPING)))
                          (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                           ERASE-OVERLAPPING MOVE-OVERLAPPING))
                        (DELETE-STALE-UPDATING-OUTPUT RECORD))
                     (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                      STREAM)))))))))
36: (SB-C::IR1-CONVERT-FUNCTION
     #<SB-C::CTRAN 10 {145318A9}>
     #<SB-C::CTRAN 11 {145329D9}>
     #<SB-C::LVAR 12 {145329F1}>
     #'(SB-INT:NAMED-LAMBDA
        (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
         (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
        (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
         SB-PCL::.REST-ARG.)
        (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
         (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
        (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
        (DECLARE
         (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
          (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
          (CHECK-OVERLAPPING T)))
        (DECLARE
         (SB-PCL::%METHOD-NAME
          (REDISPLAY-OUTPUT-RECORD
           (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
        (DECLARE (IGNORABLE STREAM RECORD))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM)))))))))
37: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 10 {145318A9}>
     #<SB-C::CTRAN 11 {145329D9}>
     #<SB-C::LVAR 12 {145329F1}>
     #'(SB-INT:NAMED-LAMBDA
        (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
         (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
        (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
         SB-PCL::.REST-ARG.)
        (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
         (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
        (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
        (DECLARE
         (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
          (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
          (CHECK-OVERLAPPING T)))
        (DECLARE
         (SB-PCL::%METHOD-NAME
          (REDISPLAY-OUTPUT-RECORD
           (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
        (DECLARE (IGNORABLE STREAM RECORD))
        (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
          (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
           ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
            SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
            :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
            :METHOD-NAME-DECLARATION
            ((REDISPLAY-OUTPUT-RECORD
              (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
            :CLOSUREP NIL :APPLYP T)
           (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
           (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
           (BLOCK REDISPLAY-OUTPUT-RECORD
             (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                   (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                         (CURRENT-GRAPHICS-STATE
                          (MEDIUM-GRAPHICS-STATE STREAM)))
                     (UNWIND-PROTECT
                         (PROGN
                          (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                (SET-MEDIUM-CURSOR-POSITION
                                 (START-GRAPHICS-STATE RECORD) STREAM)
                                (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                (WHEN *DUMP-UPDATING-OUTPUT*
                                  (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                          (MULTIPLE-VALUE-BIND
                              (ERASES MOVES DRAWS ERASE-OVERLAPPING
                               MOVE-OVERLAPPING)
                              (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                            (WHEN *TRACE-UPDATING-OUTPUT*
                              (LET ((*PRINT-PRETTY* T))
                                (FORMAT *TRACE-OUTPUT*
                                        "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                        ERASES MOVES DRAWS ERASE-OVERLAPPING
                                        MOVE-OVERLAPPING)))
                            (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                             DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                          (DELETE-STALE-UPDATING-OUTPUT RECORD))
                       (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                        STREAM)))))))))
38: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 10 {145318A9}>
     #<SB-C::CTRAN 11 {145329D9}>
     #<SB-C::LVAR 12 {145329F1}>
     (SB-INT:NAMED-LAMBDA
      (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
       (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
      (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
       SB-PCL::.REST-ARG.)
      (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
       (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
      (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
      (DECLARE
       (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
        (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL (CHECK-OVERLAPPING T)))
      (DECLARE
       (SB-PCL::%METHOD-NAME
        (REDISPLAY-OUTPUT-RECORD
         (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
      (DECLARE (IGNORABLE STREAM RECORD))
      (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
        (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
         ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
          SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
          :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
          :METHOD-NAME-DECLARATION
          ((REDISPLAY-OUTPUT-RECORD
            (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
          :CLOSUREP NIL :APPLYP T)
         (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
         (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
         (BLOCK REDISPLAY-OUTPUT-RECORD
           (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                 (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                       (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                   (UNWIND-PROTECT
                       (PROGN
                        (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                              (SET-MEDIUM-CURSOR-POSITION
                               (START-GRAPHICS-STATE RECORD) STREAM)
                              (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                              (WHEN *DUMP-UPDATING-OUTPUT*
                                (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                        (MULTIPLE-VALUE-BIND
                            (ERASES MOVES DRAWS ERASE-OVERLAPPING
                             MOVE-OVERLAPPING)
                            (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                          (WHEN *TRACE-UPDATING-OUTPUT*
                            (LET ((*PRINT-PRETTY* T))
                              (FORMAT *TRACE-OUTPUT*
                                      "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                      ERASES MOVES DRAWS ERASE-OVERLAPPING
                                      MOVE-OVERLAPPING)))
                          (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                           ERASE-OVERLAPPING MOVE-OVERLAPPING))
                        (DELETE-STALE-UPDATING-OUTPUT RECORD))
                     (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                      STREAM)))))))))
39: (SB-C::IR1-CONVERT-COMBINATION-ARGS
     #<SB-C::LVAR 13 {145318C1}>
     #<SB-C::CTRAN 10 {145318A9}>
     #<SB-C::CTRAN 14 {14531789}>
     #<SB-C::LVAR 15 {145317A1}>
     ((SB-INT:NAMED-LAMBDA
       (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
        (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
       (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
        SB-PCL::.REST-ARG.)
       (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
        (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
       (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
       (DECLARE
        (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
         (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
         (CHECK-OVERLAPPING T)))
       (DECLARE
        (SB-PCL::%METHOD-NAME
         (REDISPLAY-OUTPUT-RECORD
          (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
       (DECLARE (IGNORABLE STREAM RECORD))
       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
          ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
           SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
           :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
           :METHOD-NAME-DECLARATION
           ((REDISPLAY-OUTPUT-RECORD
             (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
           :CLOSUREP NIL :APPLYP T)
          (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
          (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
          (BLOCK REDISPLAY-OUTPUT-RECORD
            (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                        (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                    (UNWIND-PROTECT
                        (PROGN
                         (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                               (SET-MEDIUM-CURSOR-POSITION
                                (START-GRAPHICS-STATE RECORD) STREAM)
                               (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                               (WHEN *DUMP-UPDATING-OUTPUT*
                                 (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                         (MULTIPLE-VALUE-BIND
                             (ERASES MOVES DRAWS ERASE-OVERLAPPING
                              MOVE-OVERLAPPING)
                             (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                           (WHEN *TRACE-UPDATING-OUTPUT*
                             (LET ((*PRINT-PRETTY* T))
                               (FORMAT *TRACE-OUTPUT*
                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                       ERASES MOVES DRAWS ERASE-OVERLAPPING
                                       MOVE-OVERLAPPING)))
                           (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                            ERASE-OVERLAPPING MOVE-OVERLAPPING))
                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                      (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                       STREAM))))))))))
40: (SB-C::IR1-CONVERT-AUX-BINDINGS
     #<SB-C::CTRAN 16 {14531639}>
     #<SB-C::CTRAN 14 {14531789}>
     #<SB-C::LVAR 15 {145317A1}>
     ((SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                 SB-PCL::FMF
                                                 '(:ARG-INFO (2 . T))))
      SB-PCL::MF)
     (#<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::FMF {145317D9}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::MF {14531831}>)
     ((SB-INT:NAMED-LAMBDA
       (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
        (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
       (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
        SB-PCL::.REST-ARG.)
       (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
        (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
       (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
       (DECLARE
        (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
         (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
         (CHECK-OVERLAPPING T)))
       (DECLARE
        (SB-PCL::%METHOD-NAME
         (REDISPLAY-OUTPUT-RECORD
          (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
       (DECLARE (IGNORABLE STREAM RECORD))
       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
          ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
           SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
           :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
           :METHOD-NAME-DECLARATION
           ((REDISPLAY-OUTPUT-RECORD
             (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
           :CLOSUREP NIL :APPLYP T)
          (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
          (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
          (BLOCK REDISPLAY-OUTPUT-RECORD
            (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                  (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                        (CURRENT-GRAPHICS-STATE (MEDIUM-GRAPHICS-STATE STREAM)))
                    (UNWIND-PROTECT
                        (PROGN
                         (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                               (SET-MEDIUM-CURSOR-POSITION
                                (START-GRAPHICS-STATE RECORD) STREAM)
                               (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                               (WHEN *DUMP-UPDATING-OUTPUT*
                                 (DUMP-UPDATING RECORD :BOTH *TRACE-OUTPUT*)))
                         (MULTIPLE-VALUE-BIND
                             (ERASES MOVES DRAWS ERASE-OVERLAPPING
                              MOVE-OVERLAPPING)
                             (COMPUTE-DIFFERENCE-SET RECORD CHECK-OVERLAPPING)
                           (WHEN *TRACE-UPDATING-OUTPUT*
                             (LET ((*PRINT-PRETTY* T))
                               (FORMAT *TRACE-OUTPUT*
                                       "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                       ERASES MOVES DRAWS ERASE-OVERLAPPING
                                       MOVE-OVERLAPPING)))
                           (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES DRAWS
                            ERASE-OVERLAPPING MOVE-OVERLAPPING))
                         (DELETE-STALE-UPDATING-OUTPUT RECORD))
                      (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                       STREAM))))))))
      (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL))
     NIL)
41: (SB-C::%PROCESSING-DECLS
     NIL
     (#<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::FMF {145317D9}>
      #<SB-C::LAMBDA-VAR :%SOURCE-NAME SB-PCL::MF {14531831}>)
     NIL
     #<SB-C::CTRAN 16 {14531639}>
     #<SB-C::CTRAN 14 {14531789}>
     T
     #<CLOSURE (LAMBDA #) {1453188D}>)
42: (SB-C::IR1-CONVERT-LET*
     #<SB-C::CTRAN 16 {14531639}>
     #<SB-C::CTRAN 14 {14531789}>
     #<SB-C::LVAR 15 {145317A1}>
     (LET* ((SB-PCL::FMF
             (SB-INT:NAMED-LAMBDA
              (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
               (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
              (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
               SB-PCL::.REST-ARG.)
              (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
               (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
              (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
              (DECLARE
               (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
                (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                (CHECK-OVERLAPPING T)))
              (DECLARE
               (SB-PCL::%METHOD-NAME
                (REDISPLAY-OUTPUT-RECORD
                 (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
              (DECLARE (IGNORABLE STREAM RECORD))
              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                 ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                  SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
                  :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
                  :METHOD-NAME-DECLARATION
                  ((REDISPLAY-OUTPUT-RECORD
                    (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
                  :CLOSUREP NIL :APPLYP T)
                 (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                 (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                 (BLOCK REDISPLAY-OUTPUT-RECORD
                   (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                         (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                               (CURRENT-GRAPHICS-STATE
                                (MEDIUM-GRAPHICS-STATE STREAM)))
                           (UNWIND-PROTECT
                               (PROGN
                                (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                      (SET-MEDIUM-CURSOR-POSITION
                                       (START-GRAPHICS-STATE RECORD) STREAM)
                                      (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                       STREAM)
                                      (WHEN *DUMP-UPDATING-OUTPUT*
                                        (DUMP-UPDATING RECORD :BOTH
                                         *TRACE-OUTPUT*)))
                                (MULTIPLE-VALUE-BIND
                                    (ERASES MOVES DRAWS ERASE-OVERLAPPING
                                     MOVE-OVERLAPPING)
                                    (COMPUTE-DIFFERENCE-SET RECORD
                                     CHECK-OVERLAPPING)
                                  (WHEN *TRACE-UPDATING-OUTPUT*
                                    (LET ((*PRINT-PRETTY* T))
                                      (FORMAT *TRACE-OUTPUT*
                                              "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                              ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING)))
                                  (INCREMENTAL-REDISPLAY STREAM NIL ERASES
                                   MOVES DRAWS ERASE-OVERLAPPING
                                   MOVE-OVERLAPPING))
                                (DELETE-STALE-UPDATING-OUTPUT RECORD))
                             (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                              STREAM)))))))))
            (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                 (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                  SB-PCL::FMF
                                                  '(:ARG-INFO (2 . T))))
       SB-PCL::MF))
43: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 16 {14531639}>
     #<SB-C::CTRAN 14 {14531789}>
     #<SB-C::LVAR 15 {145317A1}>
     (LET* ((SB-PCL::FMF
             (SB-INT:NAMED-LAMBDA
              (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
               (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
              (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
               SB-PCL::.REST-ARG.)
              (DECLARE (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
               (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
              (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
              (DECLARE
               (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
                (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                (CHECK-OVERLAPPING T)))
              (DECLARE
               (SB-PCL::%METHOD-NAME
                (REDISPLAY-OUTPUT-RECORD
                 (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
              (DECLARE (IGNORABLE STREAM RECORD))
              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                 ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                  SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM) SB-PCL::.REST-ARG.
                  :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P NIL :SETQ-P T
                  :METHOD-NAME-DECLARATION
                  ((REDISPLAY-OUTPUT-RECORD
                    (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
                  :CLOSUREP NIL :APPLYP T)
                 (DECLARE (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                 (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                 (BLOCK REDISPLAY-OUTPUT-RECORD
                   (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                         (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                               (CURRENT-GRAPHICS-STATE
                                (MEDIUM-GRAPHICS-STATE STREAM)))
                           (UNWIND-PROTECT
                               (PROGN
                                (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                      (SET-MEDIUM-CURSOR-POSITION
                                       (START-GRAPHICS-STATE RECORD) STREAM)
                                      (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                       STREAM)
                                      (WHEN *DUMP-UPDATING-OUTPUT*
                                        (DUMP-UPDATING RECORD :BOTH
                                         *TRACE-OUTPUT*)))
                                (MULTIPLE-VALUE-BIND
                                    (ERASES MOVES DRAWS ERASE-OVERLAPPING
                                     MOVE-OVERLAPPING)
                                    (COMPUTE-DIFFERENCE-SET RECORD
                                     CHECK-OVERLAPPING)
                                  (WHEN *TRACE-UPDATING-OUTPUT*
                                    (LET ((*PRINT-PRETTY* T))
                                      (FORMAT *TRACE-OUTPUT*
                                              "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                              ERASES MOVES DRAWS
                                              ERASE-OVERLAPPING
                                              MOVE-OVERLAPPING)))
                                  (INCREMENTAL-REDISPLAY STREAM NIL ERASES
                                   MOVES DRAWS ERASE-OVERLAPPING
                                   MOVE-OVERLAPPING))
                                (DELETE-STALE-UPDATING-OUTPUT RECORD))
                             (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                              STREAM)))))))))
            (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                 (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                  SB-PCL::FMF
                                                  '(:ARG-INFO (2 . T))))
       SB-PCL::MF))
44: (SB-C::IR1-CONVERT-COMBINATION-ARGS
     #<SB-C::LVAR 17 {14531411}>
     #<SB-C::CTRAN 18 {145313F9}>
     #<SB-C::CTRAN 19 {14531381}>
     #<SB-C::LVAR 20 {14531399}>
     (:FUNCTION
      (LET* ((SB-PCL::FMF
              (SB-INT:NAMED-LAMBDA
               (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
                (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
               (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD STREAM
                SB-PCL::.REST-ARG.)
               (DECLARE
                (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
                (SB-EXT:DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
               (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
               (DECLARE
                (SB-PCL::%METHOD-LAMBDA-LIST (RECORD UPDATING-OUTPUT-RECORD)
                 (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                 (CHECK-OVERLAPPING T)))
               (DECLARE
                (SB-PCL::%METHOD-NAME
                 (REDISPLAY-OUTPUT-RECORD
                  (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))))
               (DECLARE (IGNORABLE STREAM RECORD))
               (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
                 (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                  ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                   SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                   SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL :NEXT-METHOD-P-P
                   NIL :SETQ-P T :METHOD-NAME-DECLARATION
                   ((REDISPLAY-OUTPUT-RECORD
                     (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN)))
                   :CLOSUREP NIL :APPLYP T)
                  (DECLARE
                   (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                  (DECLARE (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                  (BLOCK REDISPLAY-OUTPUT-RECORD
                    (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                          (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                (CURRENT-GRAPHICS-STATE
                                 (MEDIUM-GRAPHICS-STATE STREAM)))
                            (UNWIND-PROTECT
                                (PROGN
                                 (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                       (SET-MEDIUM-CURSOR-POSITION
                                        (START-GRAPHICS-STATE RECORD) STREAM)
                                       (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                        STREAM)
                                       (WHEN *DUMP-UPDATING-OUTPUT*
                                         (DUMP-UPDATING RECORD :BOTH
                                          *TRACE-OUTPUT*)))
                                 (MULTIPLE-VALUE-BIND
                                     (ERASES MOVES DRAWS ERASE-OVERLAPPING
                                      MOVE-OVERLAPPING)
                                     (COMPUTE-DIFFERENCE-SET RECORD
                                      CHECK-OVERLAPPING)
                                   (WHEN *TRACE-UPDATING-OUTPUT*
                                     (LET ((*PRINT-PRETTY* T))
                                       (FORMAT *TRACE-OUTPUT*
                                               "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                               ERASES MOVES DRAWS
                                               ERASE-OVERLAPPING
                                               MOVE-OVERLAPPING)))
                                   (INCREMENTAL-REDISPLAY STREAM NIL ERASES
                                    MOVES DRAWS ERASE-OVERLAPPING
                                    MOVE-OVERLAPPING))
                                 (DELETE-STALE-UPDATING-OUTPUT RECORD))
                              (SET-MEDIUM-CURSOR-POSITION
                               CURRENT-GRAPHICS-STATE STREAM)))))))))
             (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
        (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                  (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                   SB-PCL::FMF
                                                   '(:ARG-INFO (2 . T))))
        SB-PCL::MF)
      '(SB-PCL::PLIST (:ARG-INFO (2 . T)))))
45: (SB-C::IR1-CONVERT-COMBINATION
     #<SB-C::CTRAN 21 {14531229}>
     #<SB-C::CTRAN 19 {14531381}>
     #<SB-C::LVAR 20 {14531399}>
     (LIST* :FUNCTION
            (LET* ((SB-PCL::FMF
                    (SB-INT:NAMED-LAMBDA
                     (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
                      (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
                     (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD
                      STREAM SB-PCL::.REST-ARG.)
                     (DECLARE
                      (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
                      (SB-EXT:DISABLE-PACKAGE-LOCKS
                       SB-PCL::PV-ENV-ENVIRONMENT))
                     (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                     (DECLARE
                      (SB-PCL::%METHOD-LAMBDA-LIST
                       (RECORD UPDATING-OUTPUT-RECORD)
                       (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                       (CHECK-OVERLAPPING T)))
                     (DECLARE
                      (SB-PCL::%METHOD-NAME
                       (REDISPLAY-OUTPUT-RECORD
                        (UPDATING-OUTPUT-RECORD
                         UPDATING-OUTPUT-STREAM-MIXIN))))
                     (DECLARE (IGNORABLE STREAM RECORD))
                     (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                        SB-PCL::DEFAULT))
                       (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                        ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                         SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                         SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                         :NEXT-METHOD-P-P NIL :SETQ-P T
                         :METHOD-NAME-DECLARATION
                         ((REDISPLAY-OUTPUT-RECORD
                           (UPDATING-OUTPUT-RECORD
                            UPDATING-OUTPUT-STREAM-MIXIN)))
                         :CLOSUREP NIL :APPLYP T)
                        (DECLARE
                         (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                        (DECLARE
                         (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                        (BLOCK REDISPLAY-OUTPUT-RECORD
                          (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                      (CURRENT-GRAPHICS-STATE
                                       (MEDIUM-GRAPHICS-STATE STREAM)))
                                  (UNWIND-PROTECT
                                      (PROGN
                                       (LETF
                                        (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                        (SET-MEDIUM-CURSOR-POSITION
                                         (START-GRAPHICS-STATE RECORD) STREAM)
                                        (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                         STREAM)
                                        (WHEN *DUMP-UPDATING-OUTPUT*
                                          (DUMP-UPDATING RECORD :BOTH
                                           *TRACE-OUTPUT*)))
                                       (MULTIPLE-VALUE-BIND
                                           (ERASES MOVES DRAWS
                                            ERASE-OVERLAPPING MOVE-OVERLAPPING)
                                           (COMPUTE-DIFFERENCE-SET RECORD
                                            CHECK-OVERLAPPING)
                                         (WHEN *TRACE-UPDATING-OUTPUT*
                                           (LET ((*PRINT-PRETTY* T))
                                             (FORMAT *TRACE-OUTPUT*
                                                     "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                     ERASES MOVES DRAWS
                                                     ERASE-OVERLAPPING
                                                     MOVE-OVERLAPPING)))
                                         (INCREMENTAL-REDISPLAY STREAM NIL
                                          ERASES MOVES DRAWS ERASE-OVERLAPPING
                                          MOVE-OVERLAPPING))
                                       (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                    (SET-MEDIUM-CURSOR-POSITION
                                     CURRENT-GRAPHICS-STATE STREAM)))))))))
                   (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
              (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                         SB-PCL::FMF
                                                         '(:ARG-INFO (2 . T))))
              SB-PCL::MF)
            '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME LIST*
       :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T &REST T) (VALUES T &OPTIONAL))>
       :WHERE-FROM :DECLARED
       :KIND :GLOBAL-FUNCTION {145313C9}>)
46: (SB-C::IR1-CONVERT-COMBINATION-CHECKING-TYPE
     #<SB-C::CTRAN 21 {14531229}>
     #<SB-C::CTRAN 19 {14531381}>
     #<SB-C::LVAR 20 {14531399}>
     (LIST* :FUNCTION
            (LET* ((SB-PCL::FMF
                    (SB-INT:NAMED-LAMBDA
                     (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
                      (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
                     (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD
                      STREAM SB-PCL::.REST-ARG.)
                     (DECLARE
                      (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
                      (SB-EXT:DISABLE-PACKAGE-LOCKS
                       SB-PCL::PV-ENV-ENVIRONMENT))
                     (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                     (DECLARE
                      (SB-PCL::%METHOD-LAMBDA-LIST
                       (RECORD UPDATING-OUTPUT-RECORD)
                       (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                       (CHECK-OVERLAPPING T)))
                     (DECLARE
                      (SB-PCL::%METHOD-NAME
                       (REDISPLAY-OUTPUT-RECORD
                        (UPDATING-OUTPUT-RECORD
                         UPDATING-OUTPUT-STREAM-MIXIN))))
                     (DECLARE (IGNORABLE STREAM RECORD))
                     (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                        SB-PCL::DEFAULT))
                       (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                        ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                         SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                         SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                         :NEXT-METHOD-P-P NIL :SETQ-P T
                         :METHOD-NAME-DECLARATION
                         ((REDISPLAY-OUTPUT-RECORD
                           (UPDATING-OUTPUT-RECORD
                            UPDATING-OUTPUT-STREAM-MIXIN)))
                         :CLOSUREP NIL :APPLYP T)
                        (DECLARE
                         (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                        (DECLARE
                         (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                        (BLOCK REDISPLAY-OUTPUT-RECORD
                          (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                      (CURRENT-GRAPHICS-STATE
                                       (MEDIUM-GRAPHICS-STATE STREAM)))
                                  (UNWIND-PROTECT
                                      (PROGN
                                       (LETF
                                        (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                        (SET-MEDIUM-CURSOR-POSITION
                                         (START-GRAPHICS-STATE RECORD) STREAM)
                                        (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                         STREAM)
                                        (WHEN *DUMP-UPDATING-OUTPUT*
                                          (DUMP-UPDATING RECORD :BOTH
                                           *TRACE-OUTPUT*)))
                                       (MULTIPLE-VALUE-BIND
                                           (ERASES MOVES DRAWS
                                            ERASE-OVERLAPPING MOVE-OVERLAPPING)
                                           (COMPUTE-DIFFERENCE-SET RECORD
                                            CHECK-OVERLAPPING)
                                         (WHEN *TRACE-UPDATING-OUTPUT*
                                           (LET ((*PRINT-PRETTY* T))
                                             (FORMAT *TRACE-OUTPUT*
                                                     "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                     ERASES MOVES DRAWS
                                                     ERASE-OVERLAPPING
                                                     MOVE-OVERLAPPING)))
                                         (INCREMENTAL-REDISPLAY STREAM NIL
                                          ERASES MOVES DRAWS ERASE-OVERLAPPING
                                          MOVE-OVERLAPPING))
                                       (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                    (SET-MEDIUM-CURSOR-POSITION
                                     CURRENT-GRAPHICS-STATE STREAM)))))))))
                   (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
              (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                         SB-PCL::FMF
                                                         '(:ARG-INFO (2 . T))))
              SB-PCL::MF)
            '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME LIST*
       :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T &REST T) (VALUES T &OPTIONAL))>
       :WHERE-FROM :DECLARED
       :KIND :GLOBAL-FUNCTION {145313C9}>)
47: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 21 {14531229}>
     #<SB-C::CTRAN 19 {14531381}>
     #<SB-C::LVAR 20 {14531399}>
     (LIST* :FUNCTION
            (LET* ((SB-PCL::FMF
                    (SB-INT:NAMED-LAMBDA
                     (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
                      (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
                     (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD
                      STREAM SB-PCL::.REST-ARG.)
                     (DECLARE
                      (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
                      (SB-EXT:DISABLE-PACKAGE-LOCKS
                       SB-PCL::PV-ENV-ENVIRONMENT))
                     (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                     (DECLARE
                      (SB-PCL::%METHOD-LAMBDA-LIST
                       (RECORD UPDATING-OUTPUT-RECORD)
                       (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                       (CHECK-OVERLAPPING T)))
                     (DECLARE
                      (SB-PCL::%METHOD-NAME
                       (REDISPLAY-OUTPUT-RECORD
                        (UPDATING-OUTPUT-RECORD
                         UPDATING-OUTPUT-STREAM-MIXIN))))
                     (DECLARE (IGNORABLE STREAM RECORD))
                     (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                        SB-PCL::DEFAULT))
                       (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                        ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                         SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                         SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                         :NEXT-METHOD-P-P NIL :SETQ-P T
                         :METHOD-NAME-DECLARATION
                         ((REDISPLAY-OUTPUT-RECORD
                           (UPDATING-OUTPUT-RECORD
                            UPDATING-OUTPUT-STREAM-MIXIN)))
                         :CLOSUREP NIL :APPLYP T)
                        (DECLARE
                         (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                        (DECLARE
                         (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                        (BLOCK REDISPLAY-OUTPUT-RECORD
                          (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                      (CURRENT-GRAPHICS-STATE
                                       (MEDIUM-GRAPHICS-STATE STREAM)))
                                  (UNWIND-PROTECT
                                      (PROGN
                                       (LETF
                                        (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                        (SET-MEDIUM-CURSOR-POSITION
                                         (START-GRAPHICS-STATE RECORD) STREAM)
                                        (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                         STREAM)
                                        (WHEN *DUMP-UPDATING-OUTPUT*
                                          (DUMP-UPDATING RECORD :BOTH
                                           *TRACE-OUTPUT*)))
                                       (MULTIPLE-VALUE-BIND
                                           (ERASES MOVES DRAWS
                                            ERASE-OVERLAPPING MOVE-OVERLAPPING)
                                           (COMPUTE-DIFFERENCE-SET RECORD
                                            CHECK-OVERLAPPING)
                                         (WHEN *TRACE-UPDATING-OUTPUT*
                                           (LET ((*PRINT-PRETTY* T))
                                             (FORMAT *TRACE-OUTPUT*
                                                     "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                     ERASES MOVES DRAWS
                                                     ERASE-OVERLAPPING
                                                     MOVE-OVERLAPPING)))
                                         (INCREMENTAL-REDISPLAY STREAM NIL
                                          ERASES MOVES DRAWS ERASE-OVERLAPPING
                                          MOVE-OVERLAPPING))
                                       (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                    (SET-MEDIUM-CURSOR-POSITION
                                     CURRENT-GRAPHICS-STATE STREAM)))))))))
                   (SB-PCL::MF (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
              (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                         SB-PCL::FMF
                                                         '(:ARG-INFO (2 . T))))
              SB-PCL::MF)
            '(SB-PCL::PLIST (:ARG-INFO (2 . T)))))
48: (SB-C::IR1-CONVERT-COMBINATION-ARGS
     #<SB-C::LVAR 22 {14530819}>
     #<SB-C::CTRAN 23 {14530801}>
     #<SB-C::CTRAN 24 {145307B1}>
     NIL
     ('STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
      (LIST 'UPDATING-OUTPUT-RECORD 'UPDATING-OUTPUT-STREAM-MIXIN)
      '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
      (LIST* :FUNCTION
             (LET* ((SB-PCL::FMF
                     (SB-INT:NAMED-LAMBDA
                      (SB-PCL::FAST-METHOD REDISPLAY-OUTPUT-RECORD
                       (UPDATING-OUTPUT-RECORD UPDATING-OUTPUT-STREAM-MIXIN))
                      (SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL. RECORD
                       STREAM SB-PCL::.REST-ARG.)
                      (DECLARE
                       (IGNORABLE SB-PCL::.PV-CELL. SB-PCL::.NEXT-METHOD-CALL.)
                       (SB-EXT:DISABLE-PACKAGE-LOCKS
                        SB-PCL::PV-ENV-ENVIRONMENT))
                      (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                      (DECLARE
                       (SB-PCL::%METHOD-LAMBDA-LIST
                        (RECORD UPDATING-OUTPUT-RECORD)
                        (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                        (CHECK-OVERLAPPING T)))
                      (DECLARE
                       (SB-PCL::%METHOD-NAME
                        (REDISPLAY-OUTPUT-RECORD
                         (UPDATING-OUTPUT-RECORD
                          UPDATING-OUTPUT-STREAM-MIXIN))))
                      (DECLARE (IGNORABLE STREAM RECORD))
                      (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                         SB-PCL::DEFAULT))
                        (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                         ((RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                          SB-PCL::.NEXT-METHOD-CALL. (RECORD STREAM)
                          SB-PCL::.REST-ARG. :CALL-NEXT-METHOD-P NIL
                          :NEXT-METHOD-P-P NIL :SETQ-P T
                          :METHOD-NAME-DECLARATION
                          ((REDISPLAY-OUTPUT-RECORD
                            (UPDATING-OUTPUT-RECORD
                             UPDATING-OUTPUT-STREAM-MIXIN)))
                          :CLOSUREP NIL :APPLYP T)
                         (DECLARE
                          (SB-PCL::%CLASS STREAM UPDATING-OUTPUT-STREAM-MIXIN))
                         (DECLARE
                          (SB-PCL::%CLASS RECORD UPDATING-OUTPUT-RECORD))
                         (BLOCK REDISPLAY-OUTPUT-RECORD
                           (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                                 (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                                       (CURRENT-GRAPHICS-STATE
                                        (MEDIUM-GRAPHICS-STATE STREAM)))
                                   (UNWIND-PROTECT
                                       (PROGN
                                        (LETF
                                         (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                         (SET-MEDIUM-CURSOR-POSITION
                                          (START-GRAPHICS-STATE RECORD) STREAM)
                                         (COMPUTE-NEW-OUTPUT-RECORDS RECORD
                                          STREAM)
                                         (WHEN *DUMP-UPDATING-OUTPUT*
                                           (DUMP-UPDATING RECORD :BOTH
                                            *TRACE-OUTPUT*)))
                                        (MULTIPLE-VALUE-BIND
                                            (ERASES MOVES DRAWS
                                             ERASE-OVERLAPPING
                                             MOVE-OVERLAPPING)
                                            (COMPUTE-DIFFERENCE-SET RECORD
                                             CHECK-OVERLAPPING)
                                          (WHEN *TRACE-UPDATING-OUTPUT*
                                            (LET ((*PRINT-PRETTY* T))
                                              (FORMAT *TRACE-OUTPUT*
                                                      "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                      ERASES MOVES DRAWS
                                                      ERASE-OVERLAPPING
                                                      MOVE-OVERLAPPING)))
                                          (INCREMENTAL-REDISPLAY STREAM NIL
                                           ERASES MOVES DRAWS ERASE-OVERLAPPING
                                           MOVE-OVERLAPPING))
                                        (DELETE-STALE-UPDATING-OUTPUT RECORD))
                                     (SET-MEDIUM-CURSOR-POSITION
                                      CURRENT-GRAPHICS-STATE STREAM)))))))))
                    (SB-PCL::MF
                     (SB-PCL::%MAKE-METHOD-FUNCTION SB-PCL::FMF NIL)))
               (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION SB-PCL::MF
                                                         (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                                          SB-PCL::FMF
                                                          '(:ARG-INFO
                                                            (2 . T))))
               SB-PCL::MF)
             '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
      (SB-C:SOURCE-LOCATION)))
49: (SB-C::IR1-CONVERT-COMBINATION
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 24 {145307B1}>
     NIL
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME SB-PCL::LOAD-DEFMETHOD
       :TYPE #<SB-KERNEL:BUILT-IN-CLASSOID FUNCTION (read-only)>
       :WHERE-FROM :DEFINED
       :KIND :GLOBAL-FUNCTION {145307D1}>)
50: (SB-C::IR1-CONVERT-COMBINATION-CHECKING-TYPE
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 24 {145307B1}>
     NIL
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION))
     #<SB-C::GLOBAL-VAR
       :%SOURCE-NAME SB-PCL::LOAD-DEFMETHOD
       :TYPE #<SB-KERNEL:BUILT-IN-CLASSOID FUNCTION (read-only)>
       :WHERE-FROM :DEFINED
       :KIND :GLOBAL-FUNCTION {145307D1}>)
51: (SB-C::IR1-CONVERT
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 24 {145307B1}>
     NIL
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION)))
52: (SB-C::IR1-CONVERT-PROGN-BODY
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 26 {145305E1}>
     #<SB-C::LVAR 27 {145305F9}>
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      NIL))
53: (SB-C::IR1-CONVERT-AUX-BINDINGS
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 26 {145305E1}>
     #<SB-C::LVAR 27 {145305F9}>
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      NIL)
     NIL
     NIL
     NIL)
54: (SB-C::IR1-CONVERT-SPECIAL-BINDINGS
     #<SB-C::CTRAN 25 {14530719}>
     #<SB-C::CTRAN 26 {145305E1}>
     #<SB-C::LVAR 27 {145305F9}>
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      NIL)
     NIL
     NIL
     NIL
     NIL)
55: (SB-C::IR1-CONVERT-LAMBDA-BODY
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      NIL)
     NIL)
56: (SB-C::IR1-TOPLEVEL
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION))
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      (PROGN
       (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                               (LIST 'UPDATING-OUTPUT-RECORD
                                     'UPDATING-OUTPUT-STREAM-MIXIN)
                               '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                               (LIST* :FUNCTION
                                      (LET* ((SB-PCL::FMF
                                              (SB-INT:NAMED-LAMBDA
                                               (SB-PCL::FAST-METHOD
                                                REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))
                                               (SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.
                                                RECORD STREAM
                                                SB-PCL::.REST-ARG.)
                                               (DECLARE
                                                (IGNORABLE SB-PCL::.PV-CELL.
                                                 SB-PCL::.NEXT-METHOD-CALL.)
                                                (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                 SB-PCL::PV-ENV-ENVIRONMENT))
                                               (DECLARE
                                                (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                 (SPACE 0)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-LAMBDA-LIST
                                                 (RECORD
                                                  UPDATING-OUTPUT-RECORD)
                                                 (STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN)
                                                 &OPTIONAL
                                                 (CHECK-OVERLAPPING T)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-NAME
                                                 (REDISPLAY-OUTPUT-RECORD
                                                  (UPDATING-OUTPUT-RECORD
                                                   UPDATING-OUTPUT-STREAM-MIXIN))))
                                               (DECLARE
                                                (IGNORABLE STREAM RECORD))
                                               (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                  SB-PCL::DEFAULT))
                                                 (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                  ((RECORD STREAM &OPTIONAL
                                                    (CHECK-OVERLAPPING T))
                                                   SB-PCL::.NEXT-METHOD-CALL.
                                                   (RECORD STREAM)
                                                   SB-PCL::.REST-ARG.
                                                   :CALL-NEXT-METHOD-P NIL
                                                   :NEXT-METHOD-P-P NIL :SETQ-P
                                                   T :METHOD-NAME-DECLARATION
                                                   ((REDISPLAY-OUTPUT-RECORD
                                                     (UPDATING-OUTPUT-RECORD
                                                      UPDATING-OUTPUT-STREAM-MIXIN)))
                                                   :CLOSUREP NIL :APPLYP T)
                                                  (DECLARE
                                                   (SB-PCL::%CLASS STREAM
                                                    UPDATING-OUTPUT-STREAM-MIXIN))
                                                  (DECLARE
                                                   (SB-PCL::%CLASS RECORD
                                                    UPDATING-OUTPUT-RECORD))
                                                  (BLOCK
                                                      REDISPLAY-OUTPUT-RECORD
                                                    (LETF
                                                     (((SLOT-VALUE STREAM
                                                                   'REDISPLAYING-P)
                                                       T))
                                                     (LET ((*CURRENT-UPDATING-OUTPUT*
                                                            RECORD)
                                                           (CURRENT-GRAPHICS-STATE
                                                            (MEDIUM-GRAPHICS-STATE
                                                             STREAM)))
                                                       (UNWIND-PROTECT
                                                           (PROGN
                                                            (LETF
                                                             (((DO-NOTE-OUTPUT-RECORD
                                                                STREAM)
                                                               NIL))
                                                             (SET-MEDIUM-CURSOR-POSITION
                                                              (START-GRAPHICS-STATE
                                                               RECORD)
                                                              STREAM)
                                                             (COMPUTE-NEW-OUTPUT-RECORDS
                                                              RECORD STREAM)
                                                             (WHEN
                                                                 *DUMP-UPDATING-OUTPUT*
                                                               (DUMP-UPDATING
                                                                RECORD :BOTH
                                                                *TRACE-OUTPUT*)))
                                                            (MULTIPLE-VALUE-BIND
                                                                (ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)
                                                                (COMPUTE-DIFFERENCE-SET
                                                                 RECORD
                                                                 CHECK-OVERLAPPING)
                                                              (WHEN
                                                                  *TRACE-UPDATING-OUTPUT*
                                                                (LET ((*PRINT-PRETTY*
                                                                       T))
                                                                  (FORMAT
                                                                   *TRACE-OUTPUT*
                                                                   "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                   ERASES MOVES
                                                                   DRAWS
                                                                   ERASE-OVERLAPPING
                                                                   MOVE-OVERLAPPING)))
                                                              (INCREMENTAL-REDISPLAY
                                                               STREAM NIL
                                                               ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING))
                                                            (DELETE-STALE-UPDATING-OUTPUT
                                                             RECORD))
                                                         (SET-MEDIUM-CURSOR-POSITION
                                                          CURRENT-GRAPHICS-STATE
                                                          STREAM)))))))))
                                             (SB-PCL::MF
                                              (SB-PCL::%MAKE-METHOD-FUNCTION
                                               SB-PCL::FMF NIL)))
                                        (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                         SB-PCL::MF
                                         (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                          SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                        SB-PCL::MF)
                                      '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                               (SB-C:SOURCE-LOCATION)))
      SB-C::ORIGINAL-SOURCE-START 0 76)
     NIL)
57: (SB-C::CONVERT-AND-MAYBE-COMPILE
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION))
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION))
      (PROGN
       (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                               (LIST 'UPDATING-OUTPUT-RECORD
                                     'UPDATING-OUTPUT-STREAM-MIXIN)
                               '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                               (LIST* :FUNCTION
                                      (LET* ((SB-PCL::FMF
                                              (SB-INT:NAMED-LAMBDA
                                               (SB-PCL::FAST-METHOD
                                                REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))
                                               (SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.
                                                RECORD STREAM
                                                SB-PCL::.REST-ARG.)
                                               (DECLARE
                                                (IGNORABLE SB-PCL::.PV-CELL.
                                                 SB-PCL::.NEXT-METHOD-CALL.)
                                                (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                 SB-PCL::PV-ENV-ENVIRONMENT))
                                               (DECLARE
                                                (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                 (SPACE 0)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-LAMBDA-LIST
                                                 (RECORD
                                                  UPDATING-OUTPUT-RECORD)
                                                 (STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN)
                                                 &OPTIONAL
                                                 (CHECK-OVERLAPPING T)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-NAME
                                                 (REDISPLAY-OUTPUT-RECORD
                                                  (UPDATING-OUTPUT-RECORD
                                                   UPDATING-OUTPUT-STREAM-MIXIN))))
                                               (DECLARE
                                                (IGNORABLE STREAM RECORD))
                                               (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                  SB-PCL::DEFAULT))
                                                 (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                  ((RECORD STREAM &OPTIONAL
                                                    (CHECK-OVERLAPPING T))
                                                   SB-PCL::.NEXT-METHOD-CALL.
                                                   (RECORD STREAM)
                                                   SB-PCL::.REST-ARG.
                                                   :CALL-NEXT-METHOD-P NIL
                                                   :NEXT-METHOD-P-P NIL :SETQ-P
                                                   T :METHOD-NAME-DECLARATION
                                                   ((REDISPLAY-OUTPUT-RECORD
                                                     (UPDATING-OUTPUT-RECORD
                                                      UPDATING-OUTPUT-STREAM-MIXIN)))
                                                   :CLOSUREP NIL :APPLYP T)
                                                  (DECLARE
                                                   (SB-PCL::%CLASS STREAM
                                                    UPDATING-OUTPUT-STREAM-MIXIN))
                                                  (DECLARE
                                                   (SB-PCL::%CLASS RECORD
                                                    UPDATING-OUTPUT-RECORD))
                                                  (BLOCK
                                                      REDISPLAY-OUTPUT-RECORD
                                                    (LETF
                                                     (((SLOT-VALUE STREAM
                                                                   'REDISPLAYING-P)
                                                       T))
                                                     (LET ((*CURRENT-UPDATING-OUTPUT*
                                                            RECORD)
                                                           (CURRENT-GRAPHICS-STATE
                                                            (MEDIUM-GRAPHICS-STATE
                                                             STREAM)))
                                                       (UNWIND-PROTECT
                                                           (PROGN
                                                            (LETF
                                                             (((DO-NOTE-OUTPUT-RECORD
                                                                STREAM)
                                                               NIL))
                                                             (SET-MEDIUM-CURSOR-POSITION
                                                              (START-GRAPHICS-STATE
                                                               RECORD)
                                                              STREAM)
                                                             (COMPUTE-NEW-OUTPUT-RECORDS
                                                              RECORD STREAM)
                                                             (WHEN
                                                                 *DUMP-UPDATING-OUTPUT*
                                                               (DUMP-UPDATING
                                                                RECORD :BOTH
                                                                *TRACE-OUTPUT*)))
                                                            (MULTIPLE-VALUE-BIND
                                                                (ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)
                                                                (COMPUTE-DIFFERENCE-SET
                                                                 RECORD
                                                                 CHECK-OVERLAPPING)
                                                              (WHEN
                                                                  *TRACE-UPDATING-OUTPUT*
                                                                (LET ((*PRINT-PRETTY*
                                                                       T))
                                                                  (FORMAT
                                                                   *TRACE-OUTPUT*
                                                                   "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                   ERASES MOVES
                                                                   DRAWS
                                                                   ERASE-OVERLAPPING
                                                                   MOVE-OVERLAPPING)))
                                                              (INCREMENTAL-REDISPLAY
                                                               STREAM NIL
                                                               ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING))
                                                            (DELETE-STALE-UPDATING-OUTPUT
                                                             RECORD))
                                                         (SET-MEDIUM-CURSOR-POSITION
                                                          CURRENT-GRAPHICS-STATE
                                                          STREAM)))))))))
                                             (SB-PCL::MF
                                              (SB-PCL::%MAKE-METHOD-FUNCTION
                                               SB-PCL::FMF NIL)))
                                        (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                         SB-PCL::MF
                                         (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                          SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                        SB-PCL::MF)
                                      '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                               (SB-C:SOURCE-LOCATION)))
      SB-C::ORIGINAL-SOURCE-START 0 76))
58: ((FLET SB-C::DEFAULT-PROCESSOR)
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION)))
59: (SB-C::PROCESS-TOPLEVEL-FORM
     (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                             (LIST 'UPDATING-OUTPUT-RECORD
                                   'UPDATING-OUTPUT-STREAM-MIXIN)
                             '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                             (LIST* :FUNCTION
                                    (LET* ((SB-PCL::FMF
                                            (SB-INT:NAMED-LAMBDA
                                             (SB-PCL::FAST-METHOD
                                              REDISPLAY-OUTPUT-RECORD
                                              (UPDATING-OUTPUT-RECORD
                                               UPDATING-OUTPUT-STREAM-MIXIN))
                                             (SB-PCL::.PV-CELL.
                                              SB-PCL::.NEXT-METHOD-CALL. RECORD
                                              STREAM SB-PCL::.REST-ARG.)
                                             (DECLARE
                                              (IGNORABLE SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.)
                                              (SB-EXT:DISABLE-PACKAGE-LOCKS
                                               SB-PCL::PV-ENV-ENVIRONMENT))
                                             (DECLARE
                                              (OPTIMIZE (DEBUG 2) (SPEED 0)
                                               (SPACE 0)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-LAMBDA-LIST
                                               (RECORD UPDATING-OUTPUT-RECORD)
                                               (STREAM
                                                UPDATING-OUTPUT-STREAM-MIXIN)
                                               &OPTIONAL
                                               (CHECK-OVERLAPPING T)))
                                             (DECLARE
                                              (SB-PCL::%METHOD-NAME
                                               (REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))))
                                             (DECLARE
                                              (IGNORABLE STREAM RECORD))
                                             (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                SB-PCL::DEFAULT))
                                               (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                ((RECORD STREAM &OPTIONAL
                                                  (CHECK-OVERLAPPING T))
                                                 SB-PCL::.NEXT-METHOD-CALL.
                                                 (RECORD STREAM)
                                                 SB-PCL::.REST-ARG.
                                                 :CALL-NEXT-METHOD-P NIL
                                                 :NEXT-METHOD-P-P NIL :SETQ-P T
                                                 :METHOD-NAME-DECLARATION
                                                 ((REDISPLAY-OUTPUT-RECORD
                                                   (UPDATING-OUTPUT-RECORD
                                                    UPDATING-OUTPUT-STREAM-MIXIN)))
                                                 :CLOSUREP NIL :APPLYP T)
                                                (DECLARE
                                                 (SB-PCL::%CLASS STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN))
                                                (DECLARE
                                                 (SB-PCL::%CLASS RECORD
                                                  UPDATING-OUTPUT-RECORD))
                                                (BLOCK REDISPLAY-OUTPUT-RECORD
                                                  (LETF
                                                   (((SLOT-VALUE STREAM
                                                                 'REDISPLAYING-P)
                                                     T))
                                                   (LET ((*CURRENT-UPDATING-OUTPUT*
                                                          RECORD)
                                                         (CURRENT-GRAPHICS-STATE
                                                          (MEDIUM-GRAPHICS-STATE
                                                           STREAM)))
                                                     (UNWIND-PROTECT
                                                         (PROGN
                                                          (LETF
                                                           (((DO-NOTE-OUTPUT-RECORD
                                                              STREAM)
                                                             NIL))
                                                           (SET-MEDIUM-CURSOR-POSITION
                                                            (START-GRAPHICS-STATE
                                                             RECORD)
                                                            STREAM)
                                                           (COMPUTE-NEW-OUTPUT-RECORDS
                                                            RECORD STREAM)
                                                           (WHEN
                                                               *DUMP-UPDATING-OUTPUT*
                                                             (DUMP-UPDATING
                                                              RECORD :BOTH
                                                              *TRACE-OUTPUT*)))
                                                          (MULTIPLE-VALUE-BIND
                                                              (ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING)
                                                              (COMPUTE-DIFFERENCE-SET
                                                               RECORD
                                                               CHECK-OVERLAPPING)
                                                            (WHEN
                                                                *TRACE-UPDATING-OUTPUT*
                                                              (LET ((*PRINT-PRETTY*
                                                                     T))
                                                                (FORMAT
                                                                 *TRACE-OUTPUT*
                                                                 "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                 ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)))
                                                            (INCREMENTAL-REDISPLAY
                                                             STREAM NIL ERASES
                                                             MOVES DRAWS
                                                             ERASE-OVERLAPPING
                                                             MOVE-OVERLAPPING))
                                                          (DELETE-STALE-UPDATING-OUTPUT
                                                           RECORD))
                                                       (SET-MEDIUM-CURSOR-POSITION
                                                        CURRENT-GRAPHICS-STATE
                                                        STREAM)))))))))
                                           (SB-PCL::MF
                                            (SB-PCL::%MAKE-METHOD-FUNCTION
                                             SB-PCL::FMF NIL)))
                                      (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                       SB-PCL::MF
                                       (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                        SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                      SB-PCL::MF)
                                    '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                             (SB-C:SOURCE-LOCATION))
     ((PROGN
       (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                               (LIST 'UPDATING-OUTPUT-RECORD
                                     'UPDATING-OUTPUT-STREAM-MIXIN)
                               '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                               (LIST* :FUNCTION
                                      (LET* ((SB-PCL::FMF
                                              (SB-INT:NAMED-LAMBDA
                                               (SB-PCL::FAST-METHOD
                                                REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))
                                               (SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.
                                                RECORD STREAM
                                                SB-PCL::.REST-ARG.)
                                               (DECLARE
                                                (IGNORABLE SB-PCL::.PV-CELL.
                                                 SB-PCL::.NEXT-METHOD-CALL.)
                                                (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                 SB-PCL::PV-ENV-ENVIRONMENT))
                                               (DECLARE
                                                (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                 (SPACE 0)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-LAMBDA-LIST
                                                 (RECORD
                                                  UPDATING-OUTPUT-RECORD)
                                                 (STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN)
                                                 &OPTIONAL
                                                 (CHECK-OVERLAPPING T)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-NAME
                                                 (REDISPLAY-OUTPUT-RECORD
                                                  (UPDATING-OUTPUT-RECORD
                                                   UPDATING-OUTPUT-STREAM-MIXIN))))
                                               (DECLARE
                                                (IGNORABLE STREAM RECORD))
                                               (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                  SB-PCL::DEFAULT))
                                                 (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                  ((RECORD STREAM &OPTIONAL
                                                    (CHECK-OVERLAPPING T))
                                                   SB-PCL::.NEXT-METHOD-CALL.
                                                   (RECORD STREAM)
                                                   SB-PCL::.REST-ARG.
                                                   :CALL-NEXT-METHOD-P NIL
                                                   :NEXT-METHOD-P-P NIL :SETQ-P
                                                   T :METHOD-NAME-DECLARATION
                                                   ((REDISPLAY-OUTPUT-RECORD
                                                     (UPDATING-OUTPUT-RECORD
                                                      UPDATING-OUTPUT-STREAM-MIXIN)))
                                                   :CLOSUREP NIL :APPLYP T)
                                                  (DECLARE
                                                   (SB-PCL::%CLASS STREAM
                                                    UPDATING-OUTPUT-STREAM-MIXIN))
                                                  (DECLARE
                                                   (SB-PCL::%CLASS RECORD
                                                    UPDATING-OUTPUT-RECORD))
                                                  (BLOCK
                                                      REDISPLAY-OUTPUT-RECORD
                                                    (LETF
                                                     (((SLOT-VALUE STREAM
                                                                   'REDISPLAYING-P)
                                                       T))
                                                     (LET ((*CURRENT-UPDATING-OUTPUT*
                                                            RECORD)
                                                           (CURRENT-GRAPHICS-STATE
                                                            (MEDIUM-GRAPHICS-STATE
                                                             STREAM)))
                                                       (UNWIND-PROTECT
                                                           (PROGN
                                                            (LETF
                                                             (((DO-NOTE-OUTPUT-RECORD
                                                                STREAM)
                                                               NIL))
                                                             (SET-MEDIUM-CURSOR-POSITION
                                                              (START-GRAPHICS-STATE
                                                               RECORD)
                                                              STREAM)
                                                             (COMPUTE-NEW-OUTPUT-RECORDS
                                                              RECORD STREAM)
                                                             (WHEN
                                                                 *DUMP-UPDATING-OUTPUT*
                                                               (DUMP-UPDATING
                                                                RECORD :BOTH
                                                                *TRACE-OUTPUT*)))
                                                            (MULTIPLE-VALUE-BIND
                                                                (ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)
                                                                (COMPUTE-DIFFERENCE-SET
                                                                 RECORD
                                                                 CHECK-OVERLAPPING)
                                                              (WHEN
                                                                  *TRACE-UPDATING-OUTPUT*
                                                                (LET ((*PRINT-PRETTY*
                                                                       T))
                                                                  (FORMAT
                                                                   *TRACE-OUTPUT*
                                                                   "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                   ERASES MOVES
                                                                   DRAWS
                                                                   ERASE-OVERLAPPING
                                                                   MOVE-OVERLAPPING)))
                                                              (INCREMENTAL-REDISPLAY
                                                               STREAM NIL
                                                               ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING))
                                                            (DELETE-STALE-UPDATING-OUTPUT
                                                             RECORD))
                                                         (SET-MEDIUM-CURSOR-POSITION
                                                          CURRENT-GRAPHICS-STATE
                                                          STREAM)))))))))
                                             (SB-PCL::MF
                                              (SB-PCL::%MAKE-METHOD-FUNCTION
                                               SB-PCL::FMF NIL)))
                                        (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                         SB-PCL::MF
                                         (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                          SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                        SB-PCL::MF)
                                      '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                               (SB-C:SOURCE-LOCATION)))
      SB-C::ORIGINAL-SOURCE-START 0 76)
     NIL)
60: (SB-C::PROCESS-TOPLEVEL-PROGN
     ((SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION)))
     ((PROGN
       (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                               (LIST 'UPDATING-OUTPUT-RECORD
                                     'UPDATING-OUTPUT-STREAM-MIXIN)
                               '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                               (LIST* :FUNCTION
                                      (LET* ((SB-PCL::FMF
                                              (SB-INT:NAMED-LAMBDA
                                               (SB-PCL::FAST-METHOD
                                                REDISPLAY-OUTPUT-RECORD
                                                (UPDATING-OUTPUT-RECORD
                                                 UPDATING-OUTPUT-STREAM-MIXIN))
                                               (SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.
                                                RECORD STREAM
                                                SB-PCL::.REST-ARG.)
                                               (DECLARE
                                                (IGNORABLE SB-PCL::.PV-CELL.
                                                 SB-PCL::.NEXT-METHOD-CALL.)
                                                (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                 SB-PCL::PV-ENV-ENVIRONMENT))
                                               (DECLARE
                                                (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                 (SPACE 0)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-LAMBDA-LIST
                                                 (RECORD
                                                  UPDATING-OUTPUT-RECORD)
                                                 (STREAM
                                                  UPDATING-OUTPUT-STREAM-MIXIN)
                                                 &OPTIONAL
                                                 (CHECK-OVERLAPPING T)))
                                               (DECLARE
                                                (SB-PCL::%METHOD-NAME
                                                 (REDISPLAY-OUTPUT-RECORD
                                                  (UPDATING-OUTPUT-RECORD
                                                   UPDATING-OUTPUT-STREAM-MIXIN))))
                                               (DECLARE
                                                (IGNORABLE STREAM RECORD))
                                               (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                  SB-PCL::DEFAULT))
                                                 (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                  ((RECORD STREAM &OPTIONAL
                                                    (CHECK-OVERLAPPING T))
                                                   SB-PCL::.NEXT-METHOD-CALL.
                                                   (RECORD STREAM)
                                                   SB-PCL::.REST-ARG.
                                                   :CALL-NEXT-METHOD-P NIL
                                                   :NEXT-METHOD-P-P NIL :SETQ-P
                                                   T :METHOD-NAME-DECLARATION
                                                   ((REDISPLAY-OUTPUT-RECORD
                                                     (UPDATING-OUTPUT-RECORD
                                                      UPDATING-OUTPUT-STREAM-MIXIN)))
                                                   :CLOSUREP NIL :APPLYP T)
                                                  (DECLARE
                                                   (SB-PCL::%CLASS STREAM
                                                    UPDATING-OUTPUT-STREAM-MIXIN))
                                                  (DECLARE
                                                   (SB-PCL::%CLASS RECORD
                                                    UPDATING-OUTPUT-RECORD))
                                                  (BLOCK
                                                      REDISPLAY-OUTPUT-RECORD
                                                    (LETF
                                                     (((SLOT-VALUE STREAM
                                                                   'REDISPLAYING-P)
                                                       T))
                                                     (LET ((*CURRENT-UPDATING-OUTPUT*
                                                            RECORD)
                                                           (CURRENT-GRAPHICS-STATE
                                                            (MEDIUM-GRAPHICS-STATE
                                                             STREAM)))
                                                       (UNWIND-PROTECT
                                                           (PROGN
                                                            (LETF
                                                             (((DO-NOTE-OUTPUT-RECORD
                                                                STREAM)
                                                               NIL))
                                                             (SET-MEDIUM-CURSOR-POSITION
                                                              (START-GRAPHICS-STATE
                                                               RECORD)
                                                              STREAM)
                                                             (COMPUTE-NEW-OUTPUT-RECORDS
                                                              RECORD STREAM)
                                                             (WHEN
                                                                 *DUMP-UPDATING-OUTPUT*
                                                               (DUMP-UPDATING
                                                                RECORD :BOTH
                                                                *TRACE-OUTPUT*)))
                                                            (MULTIPLE-VALUE-BIND
                                                                (ERASES MOVES
                                                                 DRAWS
                                                                 ERASE-OVERLAPPING
                                                                 MOVE-OVERLAPPING)
                                                                (COMPUTE-DIFFERENCE-SET
                                                                 RECORD
                                                                 CHECK-OVERLAPPING)
                                                              (WHEN
                                                                  *TRACE-UPDATING-OUTPUT*
                                                                (LET ((*PRINT-PRETTY*
                                                                       T))
                                                                  (FORMAT
                                                                   *TRACE-OUTPUT*
                                                                   "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                   ERASES MOVES
                                                                   DRAWS
                                                                   ERASE-OVERLAPPING
                                                                   MOVE-OVERLAPPING)))
                                                              (INCREMENTAL-REDISPLAY
                                                               STREAM NIL
                                                               ERASES MOVES
                                                               DRAWS
                                                               ERASE-OVERLAPPING
                                                               MOVE-OVERLAPPING))
                                                            (DELETE-STALE-UPDATING-OUTPUT
                                                             RECORD))
                                                         (SET-MEDIUM-CURSOR-POSITION
                                                          CURRENT-GRAPHICS-STATE
                                                          STREAM)))))))))
                                             (SB-PCL::MF
                                              (SB-PCL::%MAKE-METHOD-FUNCTION
                                               SB-PCL::FMF NIL)))
                                        (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                         SB-PCL::MF
                                         (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                          SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                        SB-PCL::MF)
                                      '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                               (SB-C:SOURCE-LOCATION)))
      SB-C::ORIGINAL-SOURCE-START 0 76)
     NIL)
61: (SB-C::PROCESS-TOPLEVEL-FORM
     (PROGN
      (SB-PCL::LOAD-DEFMETHOD 'STANDARD-METHOD 'REDISPLAY-OUTPUT-RECORD 'NIL
                              (LIST 'UPDATING-OUTPUT-RECORD
                                    'UPDATING-OUTPUT-STREAM-MIXIN)
                              '(RECORD STREAM &OPTIONAL (CHECK-OVERLAPPING T))
                              (LIST* :FUNCTION
                                     (LET* ((SB-PCL::FMF
                                             (SB-INT:NAMED-LAMBDA
                                              (SB-PCL::FAST-METHOD
                                               REDISPLAY-OUTPUT-RECORD
                                               (UPDATING-OUTPUT-RECORD
                                                UPDATING-OUTPUT-STREAM-MIXIN))
                                              (SB-PCL::.PV-CELL.
                                               SB-PCL::.NEXT-METHOD-CALL.
                                               RECORD STREAM
                                               SB-PCL::.REST-ARG.)
                                              (DECLARE
                                               (IGNORABLE SB-PCL::.PV-CELL.
                                                SB-PCL::.NEXT-METHOD-CALL.)
                                               (SB-EXT:DISABLE-PACKAGE-LOCKS
                                                SB-PCL::PV-ENV-ENVIRONMENT))
                                              (DECLARE
                                               (OPTIMIZE (DEBUG 2) (SPEED 0)
                                                (SPACE 0)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-LAMBDA-LIST
                                                (RECORD UPDATING-OUTPUT-RECORD)
                                                (STREAM
                                                 UPDATING-OUTPUT-STREAM-MIXIN)
                                                &OPTIONAL
                                                (CHECK-OVERLAPPING T)))
                                              (DECLARE
                                               (SB-PCL::%METHOD-NAME
                                                (REDISPLAY-OUTPUT-RECORD
                                                 (UPDATING-OUTPUT-RECORD
                                                  UPDATING-OUTPUT-STREAM-MIXIN))))
                                              (DECLARE
                                               (IGNORABLE STREAM RECORD))
                                              (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT
                                                                 SB-PCL::DEFAULT))
                                                (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS
                                                 ((RECORD STREAM &OPTIONAL
                                                   (CHECK-OVERLAPPING T))
                                                  SB-PCL::.NEXT-METHOD-CALL.
                                                  (RECORD STREAM)
                                                  SB-PCL::.REST-ARG.
                                                  :CALL-NEXT-METHOD-P NIL
                                                  :NEXT-METHOD-P-P NIL :SETQ-P
                                                  T :METHOD-NAME-DECLARATION
                                                  ((REDISPLAY-OUTPUT-RECORD
                                                    (UPDATING-OUTPUT-RECORD
                                                     UPDATING-OUTPUT-STREAM-MIXIN)))
                                                  :CLOSUREP NIL :APPLYP T)
                                                 (DECLARE
                                                  (SB-PCL::%CLASS STREAM
                                                   UPDATING-OUTPUT-STREAM-MIXIN))
                                                 (DECLARE
                                                  (SB-PCL::%CLASS RECORD
                                                   UPDATING-OUTPUT-RECORD))
                                                 (BLOCK REDISPLAY-OUTPUT-RECORD
                                                   (LETF
                                                    (((SLOT-VALUE STREAM
                                                                  'REDISPLAYING-P)
                                                      T))
                                                    (LET ((*CURRENT-UPDATING-OUTPUT*
                                                           RECORD)
                                                          (CURRENT-GRAPHICS-STATE
                                                           (MEDIUM-GRAPHICS-STATE
                                                            STREAM)))
                                                      (UNWIND-PROTECT
                                                          (PROGN
                                                           (LETF
                                                            (((DO-NOTE-OUTPUT-RECORD
                                                               STREAM)
                                                              NIL))
                                                            (SET-MEDIUM-CURSOR-POSITION
                                                             (START-GRAPHICS-STATE
                                                              RECORD)
                                                             STREAM)
                                                            (COMPUTE-NEW-OUTPUT-RECORDS
                                                             RECORD STREAM)
                                                            (WHEN
                                                                *DUMP-UPDATING-OUTPUT*
                                                              (DUMP-UPDATING
                                                               RECORD :BOTH
                                                               *TRACE-OUTPUT*)))
                                                           (MULTIPLE-VALUE-BIND
                                                               (ERASES MOVES
                                                                DRAWS
                                                                ERASE-OVERLAPPING
                                                                MOVE-OVERLAPPING)
                                                               (COMPUTE-DIFFERENCE-SET
                                                                RECORD
                                                                CHECK-OVERLAPPING)
                                                             (WHEN
                                                                 *TRACE-UPDATING-OUTPUT*
                                                               (LET ((*PRINT-PRETTY*
                                                                      T))
                                                                 (FORMAT
                                                                  *TRACE-OUTPUT*
                                                                  "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                                                  ERASES MOVES
                                                                  DRAWS
                                                                  ERASE-OVERLAPPING
                                                                  MOVE-OVERLAPPING)))
                                                             (INCREMENTAL-REDISPLAY
                                                              STREAM NIL ERASES
                                                              MOVES DRAWS
                                                              ERASE-OVERLAPPING
                                                              MOVE-OVERLAPPING))
                                                           (DELETE-STALE-UPDATING-OUTPUT
                                                            RECORD))
                                                        (SET-MEDIUM-CURSOR-POSITION
                                                         CURRENT-GRAPHICS-STATE
                                                         STREAM)))))))))
                                            (SB-PCL::MF
                                             (SB-PCL::%MAKE-METHOD-FUNCTION
                                              SB-PCL::FMF NIL)))
                                       (SB-MOP:SET-FUNCALLABLE-INSTANCE-FUNCTION
                                        SB-PCL::MF
                                        (SB-PCL::METHOD-FUNCTION-FROM-FAST-FUNCTION
                                         SB-PCL::FMF '(:ARG-INFO (2 . T))))
                                       SB-PCL::MF)
                                     '(SB-PCL::PLIST (:ARG-INFO (2 . T))))
                              (SB-C:SOURCE-LOCATION)))
     (SB-C::ORIGINAL-SOURCE-START 0 76)
     NIL)
62: ((FLET SB-C::DEFAULT-PROCESSOR)
     (DEFMETHOD REDISPLAY-OUTPUT-RECORD
                ((RECORD UPDATING-OUTPUT-RECORD)
                 (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                 (CHECK-OVERLAPPING T))
                (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                      (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                            (CURRENT-GRAPHICS-STATE
                             (MEDIUM-GRAPHICS-STATE STREAM)))
                        (UNWIND-PROTECT
                            (PROGN
                             (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                   (SET-MEDIUM-CURSOR-POSITION
                                    (START-GRAPHICS-STATE RECORD) STREAM)
                                   (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                   (WHEN *DUMP-UPDATING-OUTPUT*
                                     (DUMP-UPDATING RECORD :BOTH
                                      *TRACE-OUTPUT*)))
                             (MULTIPLE-VALUE-BIND
                                 (ERASES MOVES DRAWS ERASE-OVERLAPPING
                                  MOVE-OVERLAPPING)
                                 (COMPUTE-DIFFERENCE-SET RECORD
                                  CHECK-OVERLAPPING)
                               (WHEN *TRACE-UPDATING-OUTPUT*
                                 (LET ((*PRINT-PRETTY* T))
                                   (FORMAT *TRACE-OUTPUT*
                                           "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                           ERASES MOVES DRAWS ERASE-OVERLAPPING
                                           MOVE-OVERLAPPING)))
                               (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                                DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                             (DELETE-STALE-UPDATING-OUTPUT RECORD))
                          (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                           STREAM))))))
63: (SB-C::PROCESS-TOPLEVEL-FORM
     (DEFMETHOD REDISPLAY-OUTPUT-RECORD
                ((RECORD UPDATING-OUTPUT-RECORD)
                 (STREAM UPDATING-OUTPUT-STREAM-MIXIN) &OPTIONAL
                 (CHECK-OVERLAPPING T))
                (DECLARE (OPTIMIZE (DEBUG 2) (SPEED 0) (SPACE 0)))
                (LETF (((SLOT-VALUE STREAM 'REDISPLAYING-P) T))
                      (LET ((*CURRENT-UPDATING-OUTPUT* RECORD)
                            (CURRENT-GRAPHICS-STATE
                             (MEDIUM-GRAPHICS-STATE STREAM)))
                        (UNWIND-PROTECT
                            (PROGN
                             (LETF (((DO-NOTE-OUTPUT-RECORD STREAM) NIL))
                                   (SET-MEDIUM-CURSOR-POSITION
                                    (START-GRAPHICS-STATE RECORD) STREAM)
                                   (COMPUTE-NEW-OUTPUT-RECORDS RECORD STREAM)
                                   (WHEN *DUMP-UPDATING-OUTPUT*
                                     (DUMP-UPDATING RECORD :BOTH
                                      *TRACE-OUTPUT*)))
                             (MULTIPLE-VALUE-BIND
                                 (ERASES MOVES DRAWS ERASE-OVERLAPPING
                                  MOVE-OVERLAPPING)
                                 (COMPUTE-DIFFERENCE-SET RECORD
                                  CHECK-OVERLAPPING)
                               (WHEN *TRACE-UPDATING-OUTPUT*
                                 (LET ((*PRINT-PRETTY* T))
                                   (FORMAT *TRACE-OUTPUT*
                                           "erases: ~S~%moves: ~S~%draws: ~S~%erase ~
                                    overlapping: ~S~%move overlapping: ~S~%"
                                           ERASES MOVES DRAWS ERASE-OVERLAPPING
                                           MOVE-OVERLAPPING)))
                               (INCREMENTAL-REDISPLAY STREAM NIL ERASES MOVES
                                DRAWS ERASE-OVERLAPPING MOVE-OVERLAPPING))
                             (DELETE-STALE-UPDATING-OUTPUT RECORD))
                          (SET-MEDIUM-CURSOR-POSITION CURRENT-GRAPHICS-STATE
                           STREAM)))))
     (SB-C::ORIGINAL-SOURCE-START 0 76)
     NIL)
[asdf frames cut...]

unhandled condition in --disable-debugger mode, quitting
; compilation aborted after 0:00:04
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   printed 20 notes


removing the declaration makes mcclim build again, but the build later fails when compiling clx/glx.lisp.