}* XXXLT.TXT TEXT-ONLY MODE EDITOR WRITTEN IN F3             }* 
}* BY ARISTO T. WITH LISA, ATHINA & HELENA S.   1::B::2011   }* 
}* XXX HAS 51,000 LINES WHILE XXXLT HAS 7,500 LINES.         }* 
}* IN SOME DOSBOX'ES, ESP WITH XXX, CAREFUL WHEN IN CTRW     }* 
}* AROUND LINESHIFT AREA, TO ENSURE EVERY CHARACTER HANDLED. }* 
}* ASSUMES FAMILIARITY WITH B9 EDITOR ON CTR-KEYS.           }* 
}* MOST CODE IS DERIVED FROM EARLY VERSION OF B9.            }*        
}* YOGA4D.ORG/cfdl.txt copyright & redist license.           }* 
}* AVAILABLE AT norskesites.org/XXXLT.TXT                    }* 
(( VARSTRING XXX-FILE-TO-START-SHOWING ))
((DATA XXX-WORDWRAP-POS ))
((DATA XXX-SCAN-ARRAY ))
((DATA XXX-REPL-ARRAY ))
((DATA XXX-SCAN-ACTION-HOUSE ))
((DATA XXX-SCAN-ACTION-UPC-HOUSE ))
((DATA XXX-REPL-ACTION-HOUSE ))
((DATA XXX-REPL-ACTION-UPC-HOUSE ))
((DATA XXX-WORK-SPACE ))
((DATA XXX-READ-ONLY-VAR XXX-READ-ONLY-VAR => SETBASIS ))
((DATA XXX-PAGE-LENGTH ))
((DATA XXX-PAGE-WIDTH ))
((DATA XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN ))
((DATA XXX-CLIPBOARD ))
(( VARSTRING XXX-CLIPBOARD-FIRST-LINE ))
((DATA XXX-CLIPBOARD-AMOUNT-LINES )) 
(( VARSTRING XXX-DOC-NAME ))
((DATA XXX-FILE-SHOULD-BE-STORED ))
((DATA XXX-EDIT-X ))
((DATA XXX-EDIT-Y ))
((DATA XXX-CLARIFY-STATUS-LINE ))
((DATA XXX-LINE-NUM ))
((DATA XXX-TOP-LINE-NUM 7500 XXX-TOP-LINE-NUM <<ASSERT ))
((DATA XXX-TOP-CLIPBOARD-NUM 270 XXX-TOP-CLIPBOARD-NUM <<ASSERT ))
((DATA XXX-LINE-POS ))
((DATA XXX-MARKING-ON ))
((DATA XXX-CASE-SCAN ))
((DATA XXX-MAX-LINE-USED ))
((DATA XXX-WORDWRAPPING ))
((DATA XXX-RECENT-SCAN-REPL-WARP ))
((DATA XXX-REFRESH-DANCERS-WITHIN ))
(LET XXX-REFRESH BE (( ))
  ((
    (( 1 ; XXX-REFRESH-DANCERS-WITHIN >>> => %GET => H ))
    (( 2 ; XXX-REFRESH-DANCERS-WITHIN >>> => %GET => H ))
    (( 3 ; XXX-REFRESH-DANCERS-WITHIN >>> => %GET => H ))
  )) OK)
(LET XXX-COPY-OVER-TO-CLIPBOARD (( )) 
  ((
    (( XXX-CLIPBOARD >>> => & ))
    (( BROWSER-MATRIX >>> => & ))
    (( (( 1 ; 3 ; # => GM => NOZ )) ;
      ((  2 ; 4 ; # => GM => NOZ )) => AND
      (MATCHED
        (( 1 ; 3 ; # => GM => >N5 ))
        (( 2 ; 3 ; # => GM => >N6 ))
        (( 78 => >N9 ))
        (( 2 ; 4 ; # => GM ; N6 => EQN = 1 ; 4 ; # => GM => >N9 === ))
        (( N9 ; N5 => SUB => INC => >N9 ))
        (( N9 
          (COUNT
          (( N1 ; N7 => ADD => DEC ; N8 ; XXX-WORK-SPACE >>> => GM ;
            N1 ; 1 ; ## => PM ))  
          COUNTUP) ))
        (( (( 2 ; 3 ; # => GM )) ; (( 2 ; 4 ; # => GM )) => EQN => NOT
          (MATCHED
            (( 2 ; 4 ; # => GM => >N6 )) 
            (( N6 ; (( 2 ; 3 ; # => GM )) => SUB => INC => >N1 ))
            (( 1 ; 4 ; # => GM 
              (COUNT  
                (( N1 ; N8 ; XXX-WORK-SPACE >>> => GM ;
                  N1 ; N3 ; ## => PM ))
              COUNTUP) ))
            (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) 
              => SUB => DEC => >N2 ))
            (( N2 => ISPRO 
              (MATCHED
                (( N2 
                  (COUNT
                    (( N1 ; (( 2 ; 3 ; # => GM )) => ADD ;
                      XXX-WORK-SPACE >>> => %GET => INC4 => >N7 )) 
                    (( N1 => INC ; ## => %GET => INC4 => >N8 ))
                    (( 78 => >N9 ))
                    (( N7 ; N8 ; N9 => COPYNUMS ))
                  COUNTUP) ))
              MATCHED) ))
          MATCHED) ))
        (( ## => FIX-BLANK-LINES-IN-FILE ))
        (( 1 ; ## => MATR>TEXT ; XXX-CLIPBOARD-FIRST-LINE => >VARSTR ))
      MATCHED) ))
    (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) => SUB => INC
      XXX-CLIPBOARD-AMOUNT-LINES <<ASSERT ))
    (( && ; && ))
  )) OK)
(LET XXX-REQUEST-CLIPBOARD-FIRST-LINE (( ))
  ((
    (( XXX-CLIPBOARD >>> => & ))
    (( XXX-CLIPBOARD-FIRST-LINE => VARSTR-LEN => ISBASIS  
      (MATCHED
        (( 1 ; 4 ; BROWSER-MATRIX >>> => GM => NOZ
          (MATCHED
            (( # => CLEAR-MATRIX ))                                         
            (( XXX-COPY-OVER-TO-CLIPBOARD ))                                 
            (( XXX-CLIPBOARD-FIRST-LINE => VARSTR> => => ))
          )(OTHER
            (( }} => => ))
          MATCHED) ))
      )(OTHER
        (( XXX-CLIPBOARD-FIRST-LINE => VARSTR> => => ))
      MATCHED) ))
    (( && ))
  )) OK)
(LET XXX-NEW-LINES BE (( >N7 >N6 ))
  ((
    (( N6 ; XXX-MAX-LINE-USED >>> => INTGREATER = EXIT === ))
    (( XXX-WORK-SPACE >>> => & ))
    (( N7 ; XXX-MAX-LINE-USED >>> => ADD => >N9 ))
    (( (( XXX-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => NOZ
      (MATCHED
        (( (( N6 => INC => MUL4 ; # => ADD )) ;
        (( (( N6 => INC ; N7 => ADD )) => MUL4 ; # => ADD )) ;
        (( XXX-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => COPYNUMSHIGH ))
      MATCHED) ))
    (( N7
      (COUNT
        (( XXX-PAGE-WIDTH >>> => INC => %MAKE => & ))
        (( 32 ; 1 ; # => %PUT ))
        (( GETV ; (( N1 ; N8 => ADD )) ; # => %PUT ))
      COUNTUP) ))
    (( N7 ; XXX-MAX-LINE-USED => ADDVAR ))
    (( && ))
  )) OK)
(LET XXX-PUT-IT-GOOD BE (( ))
  ((
    (( XXX-CLIPBOARD >>> => & ))
    (( XXX-WORK-SPACE >>> => & ))
    (( XXX-REQUEST-CLIPBOARD-FIRST-LINE => TOLEN => ISPRO
      (MATCHED
        (( XXX-LINE-POS >>>
          (COUNT
            (( N1 ; XXX-LINE-NUM >>> ; # => GM => ISBASIS
              (MATCHED
                (( 32 ; N1 ; XXX-LINE-NUM >>> ; # => PM ))
              MATCHED) ))
          COUNTUP) ))
        (( XXX-CLIPBOARD-AMOUNT-LINES => VISDANCE
          (MATCHED 
            (( 1 ; ## => %GET => >N8 )) 
            (( N8 => ACTIVE-LENGTH => >N9 ))
            (( N9 ; XXX-LINE-POS >>> => ADD ; 79 => INTGREATER
              (MATCHED
                (( 78 ; XXX-LINE-POS >>> => SUB => INC => >N9 ))
              MATCHED) ))
            (( 78 ; (( XXX-LINE-POS >>> ; N9 => ADD )) => 
              SUB => INC => >N10 ))
            (( N10 => ISPRO
              (MATCHED
                (( N10
                  (COUNT
                    (( (( N2 ; N1 => SUB => INC )) ; XXX-LINE-POS >>> => ADD 
                      => DEC ; XXX-LINE-NUM >>> ; # => GM ; ))
                    (( ; (( N2 ; N1 => SUB => INC )) ; N11 ; XXX-LINE-POS >>> 
                      => ADD => ADD => DEC ; XXX-LINE-NUM >>> ; # => PM ))    
                  COUNTUP) ))
              MATCHED) ))
            (( N9                            
              (COUNT
                (( N1 ; N10 => %GET ; N1 ; XXX-LINE-POS >>> => ADD 
                  => DEC ; XXX-LINE-NUM >>> ; # => PM ))   
              COUNTUP) ))                                  
          )(OTHER  
            (( XXX-CLIPBOARD-AMOUNT-LINES => VISBASIS
              = && ; && ; EXIT === ))
            (( XXX-CLIPBOARD-AMOUNT-LINES >>> ; XXX-LINE-NUM >>> =>
              ADD ; 7500 => INTGREATER = FREE-CLS ; 
} The text would, it seems, then exceed workspace.} POP 
              ENTERPLS ; && ; && ; EXIT === ))
            (( 79 => %MAKE => >N1 ))
            (( XXX-LINE-NUM >>> ; # => %GET => INC4 => >N2 ))
            (( N1 => INC4 => >N3 ))
            (( 78 => >N4 ))
            (( N2 ; N3 ; N4 => COPYNUMS ))
            (( XXX-LINE-POS >>> ; (( 78 ; BRIDGE => SUB => INC )) 
              ; (( XXX-LINE-NUM >>> ; # => %GET )) 
              ; (( 1 ; ## => %GET )) => REPLACE-SEGMENT ))
            (( XXX-LINE-NUM >>> ; XXX-CLIPBOARD-AMOUNT-LINES >>>
              => DEC => XXX-NEW-LINES ))
            (( XXX-CLIPBOARD-AMOUNT-LINES >>> => DEC
              (COUNT
                (( (( N1 INC ; ## => %GET => INC4 )) ; 
                  (( N1 ; XXX-LINE-NUM >>>
                  ADD ; # => %GET => INC4 )) ; 78 => COPYNUMS ))
              COUNTUP) ))
            (( XXX-CLIPBOARD-AMOUNT-LINES >>> ; ## => %GET
              => ACTIVE-LENGTH => >N5 ))
            (( 1 ; XXX-LINE-POS >>> => DEC ; N1 => RM-SEGMENT ))
            (( N1 => ACTIVE-LENGTH ; N1 => >MEM ))
            (( N5 => INC ; (( XXX-CLIPBOARD-AMOUNT-LINES >>> => DEC ;
              XXX-LINE-NUM >>> => ADD ; # => %GET )) 
              ; N1 => INSERT-SEGMENT ))
            (( N1 => %FREE ))
          MATCHED) ))
      MATCHED) ))
    (( && ))
    (( && ))
  )) OK)
(LET XXX-EDIT-RANGE-CONTROL BE (( ))
  ((
    (( XXX-EDIT-X >>> ; 2 ; 79 => SET-RANGE XXX-EDIT-X <<ASSERT ))
    (( XXX-EDIT-Y >>> ; 2 ; 22 => SET-RANGE XXX-EDIT-Y <<ASSERT ))
    (( XXX-LINE-NUM >>> ; 1 ; XXX-TOP-LINE-NUM >>> => SET-RANGE
      XXX-LINE-NUM <<ASSERT ))
    (( XXX-LINE-POS >>> ; 1 ; 78 => SET-RANGE
      XXX-LINE-POS <<ASSERT ))
  )) OK)
(LET XXX-EDIT-TOP-LEFT BE (( ))
  ((
    (( 2 XXX-EDIT-X <<ASSERT ))
    (( 2 XXX-EDIT-Y <<ASSERT ))
  )) OK)
(LET XXX-EDIT-NEXTEST-LEFT BE (( ))
  ((
    (( 2 XXX-EDIT-X <<ASSERT ))
    (( 22 XXX-EDIT-Y <<ASSERT ))
  )) OK)
(LET XXX-EDIT-UPPER BE (( ))
  ((
    (( -2 ; XXX-EDIT-Y => ADDVAR ))
  )) OK)
(LET XXX-EDIT-NEXTER BE (( ))
  ((
    (( 2 ; XXX-EDIT-Y => ADDVAR ))
  )) OK)
(LET XXX-EDIT-LEFTER BE (( ))
  ((
    (( -1 XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-LEFTER-10 BE (( ))
  ((
    (( -10 XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-LEFTER-2 BE (( ))
  ((
    (( -2 XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-LEFTMOST BE (( ))
  ((
    (( 2 XXX-EDIT-X <<ASSERT ))
  )) OK)
(LET XXX-EDIT-RIGHTER BE (( ))
  ((
    (( XXX-EDIT-X => INCVAR ))
  )) OK)
(LET XXX-EDIT-RIGHTER-10 BE (( ))
  ((
    (( 10 ; XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-RIGHTER-2 BE (( ))
  ((
    (( 2 ; XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-RIGHTER-4 BE (( ))
  ((
    (( 4 ; XXX-EDIT-X => ADDVAR ))
  )) OK)
(LET XXX-EDIT-RIGHTMOST BE (( ))
  ((
    (( 79 XXX-EDIT-X <<ASSERT ))
  )) OK)
(LET XXX-REDISPLAY-CURRENT-LINE BE (( ))
  ((
    (( XXX-LINE-NUM >>> ; XXX-MAX-LINE-USED >>>
      => INTGREATER = EXIT === ))
    (( XXX-LINE-NUM >>> ; XXX-WORK-SPACE >>> => %GET => & ))
    (( 1 => >N1 ))
    (( 2 ; XXX-EDIT-Y >>> => GOTOXY ))
    (( XXX-PAGE-WIDTH >>> => SPACES ))
    (( 2 ; XXX-EDIT-Y >>> => GOTOXY ))
    (( GOLABEL4: ))
    (( XXX-PAGE-WIDTH >>> ; N1 => INTGTOREQUAL
      (MATCHED
        (( N1 ; # => %GET => A
          (MATCHED
            (( ; => ASCII => ( ))
            (( INCN1 ))
            (( GOUP4 ))
          MATCHED) ))
      MATCHED) ))
    (( && ))
  )) OK)
(LET XXX-REDISPLAY-ALL-TEXT-HERE BE (( ))
  ((
    (( XXX-WORK-SPACE >>> => & ))
    (( XXX-MAX-LINE-USED >>> => ISPRO
      (MATCHED
        (( XXX-PAGE-LENGTH >>>
          (COUNT
            (( 2 ; N1 => TWICE => GOTOXY ))
            (( } } ; XXX-PAGE-WIDTH >>> => SEVERAL( ))
            (( 2 ; N1 => TWICE => GOTOXY ))
            (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N1 => ADD => DEC ;
              XXX-MAX-LINE-USED >>> => INTGREATER
              (MATCHED
                (( RMS ; RMS ))
                (( GOFORWARD4 ))
              MATCHED) ))
            (( XXX-PAGE-WIDTH >>>
              (COUNT
                (( N1 ; (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ; N3 => ADD
                  => DEC )) ; # => GM => AFFIRM
                  (MATCHED
                    (( ; => ONE ; ; ))
                    (( ; 32 ; 126 => WITH
                      (MATCHED
                        (( ; ONE => ASCII => ( ))
                      MATCHED) ))
                    (( ; => RM ))
                  )(OTHER
                    (( RMS ; RMS ))
                    (( GOFORWARD2 ))
                  MATCHED) ))
              COUNTUP) ))
            (( GOLABEL2: ))
          COUNTUP) ))
      MATCHED) ))
    (( GOLABEL4: ))
    (( && ))
  )) OK)
(LET XXX-TO-CURRENT-POS BE (( ))
  ((
    (( XXX-EDIT-X >>> ; XXX-EDIT-Y >>> => GOTOXY ))
  )) OK)
(LET XXX-TO-TOP-LINE BE (( ))
  ((
    (( 1 ; 1 => GOTOXY ))
    (( }*} ; 68 => SEVERAL( ))
  )) OK)
(LET XXX-STD-MENU-TEXT BE (( ))
  ((
    (( }*} ; 68 => SEVERAL( ))
    (( XXX-READ-ONLY-VAR => VISDANCE
      (MATCHED
        (( }F9 options} => POPS ))
      )(OTHER
        (( }F9 OPTIONS} => POPS ))
      MATCHED)
  )) OK)
(LET XXX-COMPLETE-MARKING-ON BE (( ))
  ((
    (( BROWSER-MATRIX >>> => & )) 
    (( 2 ; 3 ; # => GM => ISPRO => NOT
      (MATCHED
        (( # => CLEAR-MATRIX ))
        (( XXX-MARKING-ON => SETBASIS ))
        (( XXX-CLIPBOARD-AMOUNT-LINES => SETBASIS ))
        (( XXX-CLIPBOARD-FIRST-LINE => VARSTR-SETBASIS )) 
        (( && ; EXIT ))
      MATCHED) ))
    (( XXX-MARKING-ON => VISBASIS = && ; EXIT === ))
    (( XXX-CLIPBOARD >>> => CLEAR-MATRIX ))
    (( XXX-LINE-POS >>> => >N9  ))
    (( XXX-LINE-NUM >>> => >N10 ))
    (( 1 ; 3 ; # => GM => >N7  ))
    (( 2 ; 3 ; # => GM => >N8  ))
    (( N8 ; N10 => EQN
      (MATCHED
        (( N9 ; N7 => INTGTOREQUAL
          (MATCHED
            (( N9  ; 1 ; 4 ; # => PM ))
            (( N10 ; 2 ; 4 ; # => PM ))
          )(OTHER
            (( N9  ; 1 ; 3 ; # => PM ))
            (( N10 ; 2 ; 3 ; # => PM ))
            (( N7  ; 1 ; 4 ; # => PM ))
            (( N8  ; 2 ; 4 ; # => PM ))
          MATCHED) ))
      )(OTHER
        (( N10 ; N8 => INTGREATER
          (MATCHED
            (( N9  ; 1 ; 4 ; # => PM ))
            (( N10 ; 2 ; 4 ; # => PM ))
          )(OTHER
            (( N9  ; 1 ; 3 ; # => PM ))
            (( N10 ; 2 ; 3 ; # => PM ))
            (( N7  ; 1 ; 4 ; # => PM ))
            (( N8  ; 2 ; 4 ; # => PM ))
          MATCHED) ))
      MATCHED) ))
    (( (( (( 2 ; 4 ; # => GM )) ; (( 2 ; 3 ; # => GM )) => SUB => INC )) ;
      270 => INTGREATER
        (MATCHED
          (( # => CLEAR-MATRIX ))
          (( FREE-CLS ))
(( } THE CLIPBOARD (OF SIZE 270 LINES, BY THE WAY) } => POP ))
(( } SEEMS TO REQUIRE SOME OTHER BOUNDARIES THAN THESE,} => POP ))
(( } -- COULD YOU BE SO  V E R Y  KIND AS TO TRY AGAIN? } => POP ))
          (( ENTERPLS )) 
          (( XXX-REFRESH ))
        MATCHED) ))
    (( XXX-MARKING-ON => SETBASIS ))
    (( XXX-REQUEST-CLIPBOARD-FIRST-LINE => RM )) 
    (( && ))
  )) OK)
(LET XXX-UNDERLINECURRENT-POS BE (( ))
  ((
    (( XXX-EDIT-X >>> ; XXX-EDIT-Y >>> => INC => GOTOXY ))
    (( XXX-MARKING-ON => VISDANCE
      (MATCHED
        (( }*} ))
      )(OTHER
        (( }$} ))
      MATCHED) => (
      ))
    (( XXX-TO-CURRENT-POS ))
  )) OK)
(LET XXX-UN-UNDERLINECURRENT-POS BE (( ))
  ((
    (( XXX-EDIT-X >>> ; XXX-EDIT-Y >>> => INC => GOTOXY ))
    (( }~} => ( ))
  )) OK)
(LET XXX-REFRESH-HORISONTALS BE (( ))
  ((
    (( XXX-PAGE-LENGTH >>>
      (COUNT
        (( 2 ; (( N1 => TWICE => INC )) => GOTOXY ))
        (( }~} ; XXX-PAGE-WIDTH >>> => SEVERAL( ))
      COUNTUP) ))
    )) OK)
(LET XXX-UN-UNDERLINETHIS-MANY-FROM-CURRENT-POS BE (( >N1 ))
  ((
    (( XXX-EDIT-X >>> ; XXX-EDIT-Y >>> => INC => GOTOXY ))
    (( }~} ; N1 => SEVERAL( ))
  )) OK)
(LET XXX-MENU-LINE BE (( ))
  ((
    (( 1 ; 24 => GOTOXY ))
  )) OK)
(LET XXX-STATUS-LINE BE (( ))
  ((
    (( 1 ; 25 => GOTOXY ))
  )) OK)
(LET XXX-STATUS-LINE-NUM-POS BE (( ))
  ((
    (( 64 ; 25 => GOTOXY ))
  )) OK)
(LET XXX-SHOW-LINE-NUM-AND-POS BE (( ))
  ((
    (( XXX-STATUS-LINE-NUM-POS ))
    (( }LN #} => (
    (( XXX-LINE-NUM >>> ( ))
    (( }#} => ( ))
    (( XXX-LINE-POS >>> ( ))
  )) OK)
(LET XXX-STD-FRAME BE (( ))
  ((
    (( FREE-CLS ))
    (( CLEAR_KEYBUF ))
    (( XXX-MENU-LINE ))
    (( XXX-STD-MENU-TEXT ))
    (( XXX-TO-TOP-LINE ))
    (( XXX-REFRESH-HORISONTALS ))
  )) OK)
(LET XXX-CLARIFY-STATUS-LINE-IF-NEED-BE BE (( ))
  ((
    (( XXX-CLARIFY-STATUS-LINE => VISDANCE
      (MATCHED
        (( XXX-STATUS-LINE ))
        (( 79 => SPACES ))
        (( XXX-CLARIFY-STATUS-LINE => SETBASIS ))
      MATCHED) ))
  )) OK)
(LET XXX-SAVE-THIS-DOC-NOW BE (( ))
  ((
    (( XXX-WORK-SPACE >>> => & ))
    (( XXX-FILE-SHOULD-BE-STORED => SETBASIS ))
    (( # => FIX-BLANK-LINES-IN-FILE ))
    (( XXX-DOC-NAME => VARSTR> ; }.TXT} => CONCAT ; # => PM2FILE ; RM ))
    (( && ))
  )) OK)
(LET XXX-GET-NEW-DOC-NAME BE (( ))
  ((
    (( FREE-CLS ))
    (( CRLN ))
    ((
} S T O R I N G   Y O U R   G R E A T   W O R K S  ! ! ! ! ! ! !}
      => POP ))
    (( CRLN ))
    ((
} P L E A S E   G I V E   N E W   D O C - N A M E :}
      => POP ))
    ((
} (8-DIGITS MAX, DASH - AND HYPHEN _ AND DIGITS OKAY, .TXT}
      => POP ))
    ((
} IS ADDED BY MACHINE AUTOMATICALLY. IF EXISTING FILE HAS}
      => POP ))
    ((
} THIS NAME, IT IS AUTOMATICALLY OVERWRITTEN, SO BE CERTAIN.}
      => POP ))
    (( } ===========================================>}
      => POPS ))
    (( READLN => MAKE-SAFE-8-SIZE-FILENAME => ONE ; }.TXT}
      => CONCAT ; ; ))
    (( } THANKS.} => POP ))
    (( } WILL USE:} => POP ))
    (( } ===========================================>}
      => POPS ))
    (( ; => POPS ))
    (( ; XXX-DOC-NAME => >VARSTR ))
    (( CRLN ))
  )) OK)
(LET XXX-EXIT-MAYBE-BROWSE-MODE (( ))
  ((
    (( XXX-READ-ONLY-VAR => VISDANCE
      (MATCHED
        (( FREE-CLS ))
        (( CRLN ; CRLN ))
        ((
} BELOVED AMATEUR USER OF THE XXX EDITOR! I WELCOME YOUR}
          => POP ))
        ((
} ENTERPRISING SPIRIT!  BUT THE EDITOR HAS BEEN OPENED}
          => POP ))
        ((
} IN A MODE TO BROWSE FILES ONLY.  PLEASE REOPEN IN A SAVE/WRITE MODE}
          => POP ))
        ((
} ANY DOCUMENTS WHICH SHOULD BE ALTERED.  PROMISE YOU'LL REMEMBER}
          => POP ))
        ((
} AND BE A BETTER CITIZEN FROM NOW ON ;)   }
          => POPS ))
        (( YNIN ; RM ))
        (( YES => => ))
      )(OTHER
        (( NO => => ))
      MATCHED) ))
  )) OK)
(LET XXX-STORE-FILE-OPTION (( ))
  ((
    (( XXX-EXIT-MAYBE-BROWSE-MODE = EXIT === ))
    (( FREE-CLS ))
    (( CRLN ))
    ((
} >>>>>>>>>>>>>>>>>>>>>> T H E   X X X  S T O R E   O P T I O N}
      => POP ))
    (( XXX-FILE-SHOULD-BE-STORED => VISDANCE
      (MATCHED
        ((
} OUR SPIES TELL US THAT THE DOCUMENT IN THE RAM MIGHT HAVE}
          => POP ))
        ((
} BEEN UPDATED SOMEHOW (AS A RESULT OF YOUR KEYACTIONS).}
          => POP ))
        ((
} IF IT IS NOT STORED AT THIS POINT, WHAT IS IN RAM IS CLEARED.}
          => POP ))
      MATCHED) ))
    (( CRLN ))
    ((
} > > > > > D O C U M E N T  N A M E :   } => POP ))
    ((
}                                        } => POPS ))
    (( XXX-DOC-NAME => VARSTR> => POP ))
    ((
}                                         ======== (.TXT IS AUTOADDED)}
      => POP ))
    (( CRLN ; CRLN ; CRLN ))
    ((
} (THE PRESENT & STANDARD FILE FOLDER, C:\BOEHM\BOEHMIAN IS NORMALLY USED.}
      => POP ))
    ((
} (BEWARE: ONLY IF YOU WANT OVERWRITE, GIVE NAME OF AN EXISTING FILE.)}
      => POP ))
    (( CRLN ))
    (( } ****====>!!!!! w a n t   t o   S A V E ????} => POP ))
    (( } ****====>!!!!! w a n t   t o   S A V E ????} => POP ))
    (( } ****====>!!!!! w a n t   t o   S A V E ????} => POPS ))
    (( YNIN
      (MATCHED
        (( FREE-CLS ; CRLN ; CRLN ))
(( } > > > > > D O C U M E N T  N A M E :   } => POP ))
(( }                                        } => POPS ))
        (( XXX-DOC-NAME => VARSTR> => POP ))
(( }                                        } => POPS ))
        (( XXX-DOC-NAME => VARSTR> => POP ))
(( }                                        } => POPS ))
        (( XXX-DOC-NAME => VARSTR> => POP ))
(( } WANT TO SAVE UNDER    THE  E X I S T I N G   NAME?} => POP ))
(( } (IF NEW NAME, PLS AVOID SIMILAR NAMES AS OS NAMES)} => POP ))
        (( CRLN ))
(( } WANT TO SAVE UNDER    THE  E X I S T I N G   NAME?} => POP ))
(( } WANT TO SAVE UNDER    THE  E X I S T I N G   NAME?} => POP ))
(( } WANT TO SAVE UNDER    THE  E X I S T I N G   NAME?} => POP ))
        (( CRLN ))
(( } [PLS TYPE AN 'N' IF YOU WANT NEW NAME]            } => POPS ))
        (( YNIN => NOT
          (MATCHED
            (( XXX-GET-NEW-DOC-NAME ))
          MATCHED) ))
        (( XXX-SAVE-THIS-DOC-NOW ))
        (( CRLN ))
(( } IT SHOULD BE SAVED NOW. DO PLS CHECK IN ALL IMPORTANT CASES,} => POP ))
(( } AND CERTAINLY IF YOU HAVE USED AN UNUSUAL FILENAME.} => POP ))
(( } (NORMALLY, BLANK LINES IN THE COMPLETION OF THE DOCUMENT ARE} => POP ))
(( } NOT NECESSARILY INCLUDED, SO LINE COUNT MAY BE DIFFERENT.)} => POP ))
        (( ENTERPLS ))
      MATCHED) ))
    (( XXX-LINE-NUM => SETDANCE ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
  )) OK)
(LET XXX-MAYBE-STORE-FILE (( ))
  ((
    (( (( XXX-FILE-SHOULD-BE-STORED => VISDANCE ))
      (( XXX-READ-ONLY-VAR => VISBASIS )) => AND
      (MATCHED
        (( XXX-STORE-FILE-OPTION ))
      MATCHED) ))
  )) OK)
(LET XXX-WORD BE (( ))
  ((
    (( XXX-READ-ONLY-VAR => SETDANCE ))
    (( }README} ; }XXXLT} => ? => H ))
  )) OK)
(LET XXX-FETCH-FILE BE (( ))
  ((
    (( XXX-WORK-SPACE >>> => & ))
    (( # => CLEAR-MATRIX ))
    (( XXX-FILE-SHOULD-BE-STORED => SETBASIS ))
    (( XXX-DOC-NAME => VARSTR> =>
      CALC-AMOUNT-LINES-IN-TXT-OF-ANY-WIDTH XXX-MAX-LINE-USED <<ASSERT ))
    (( XXX-MAX-LINE-USED >>> => ISPRO => NOT
      (MATCHED
        (( XXX-MAX-LINE-USED => SETDANCE ))
      MATCHED) ))
    (( XXX-MAX-LINE-USED >>> ; 1 ; XXX-TOP-LINE-NUM >>>
      => SET-RANGE XXX-MAX-LINE-USED <<ASSERT ))
    (( XXX-DOC-NAME => VARSTR> ; }.TXT} => CONCAT ; # => FILE2PM ; RM ))
    (( # => FIX-BLANK-LINES-IN-FILE ))
    (( XXX-MAX-LINE-USED >>> ; # => FILTER-NON7ASCII-CHARS ))
    (( # => ARE-ALL-IN-RIGHTMOST-COLUMN-UNUSED => NOT
      (MATCHED
        (( # => CLEAR-MATRIX ))
        (( XXX-MAX-LINE-USED => SETDANCE ))
        (( FREE-CLS ))
        (( CRLN ; CRLN ))
        (( }LOOK, MY DEAR FRIEND, I DON'T KNOW HOW YOU HAVE PRODUCED}
          => POP ))
        (( }THIS SURELY EMINENT TEXT FILE, BUT I KNOW, FOR FACT, E.G. LINE}
          => POP ))
        (( ARE-ALL-IN-RIGHTMOST-DATA >>> ; 
          } HAS BEEN PRODUCED BY SOME OTHER EDITOR THAN XXX.} => CONCAT 
          => POP ))
        (( }WHAT I AM TRYING TO POINT OUT IS THAT YOU NEED TO RUN STH LIKE}
          => POP ))
        (( }THE WORDWRAP PROGRAM ON THIS. IT IS FAIRLY STRAIGHTFORWARD.}
          => POP ))
        (( }DO THAT, AND FIX UP PARAGRAPHS AFTERWARDS, FOR WE MUST HAVE}
          => POP ))
        (( }MAXIMUM 78 IN CHARACTER LINE LENGTH OF ALL XXX DOCUMENTS.}
          => POP ))
        (( }GREAT LUCK ON YOUR MISSION. AND WELCOME BACK ON THIS.}
          => POP ))
        (( }===> CONFIRM, I WILL DEFINITELY IMPROVE IN THE FUTURE ;)} 
          => POP ))
        (( YNIN => RM ))
        (( CRLN ; FREE-CLS ; CRLN ))
        (( XXX-LINE-NUM => SETDANCE ))
      )(OTHER
        (( XXX-LINE-NUM >>> ; 1 ; XXX-MAX-LINE-USED >>>
          => SET-RANGE XXX-LINE-NUM <<ASSERT ))
      MATCHED) ))
    (( && ))
  )) OK)
(LET XXX-LOAD-NEW-FILE BE (( ))
  ((
    (( XXX-WORK-SPACE >>> => & ))
    (( XXX-MAYBE-STORE-FILE ))
    (( FREE-CLS ))
    (( CRLN ))
    ((
} P L E A S E   T E L L   W H I C H   F I L E   T O   G E T :}
      => POP ))
    (( XXX-READ-ONLY-VAR => VISDANCE
      (MATCHED
        ((
} *******====> BROWSE-MODE IS ON. START IN ANOTHER WAY TO STORE ALSO.}
        => POP ))
        ((
} !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}
        => POP ))
    )(OTHER
      (( CRLN ))
    MATCHED) ))
    ((
} (FROM THE NORMAL STANDARD FOLDER C:\BOEHM\BOEHMIAN. THE PROGRAM}
      => POP ))
    ((
} ASSUMES THAT YOU ARE FAMILIAR WITH THE FILENAME YOU WANT TO WORK}
      => POP ))
    ((
} ON, -- IF IN DOUBT CONSULT A PROGRAM WHICH GIVES A FILELIST.}
      => POP ))
    ((
} THIS EDITOR AUTOMATICALLY ASSUMES .TXT IS THE RIGHT EXTENSION.}
      => POP ))
    ((
} IF FILENAME UNKNOWN, YOU WILL GET A NEW EMPTY BLANK WORKSPACE.}
      => POP ))
   ((
} IF YOU JUST COPIED SOMETHING, YOU CAN USE F5 TO PUT IT IN THE NEW.}
      => POP ))
   ((
} THE FILENAME YOU INDCATE HERE WILL BE SUGGESTED WHEN YOU SAVE IT.)}
      => POP ))
    (( '10' ; 5 => SEVERAL( ))
    (( } LOAD / GET=================================>}
      => POPS ))
    (( READLN => MAKE-SAFE-8-SIZE-FILENAME => ONE ;
      }.TXT} => CONCAT ; ; ))
    (( CRLN ))
    (( } THANKS.  CURRENT FILENAME IS SET TO THIS --} => POP ))
    (( } (AND FILE WILL BE ACCESSED IF EXISTS)} => POP ))
    (( } ===========================================>}
      => POPS ))
    (( ; => POPS ))
    (( ; XXX-DOC-NAME => >VARSTR ))
    (( CRLN ))
    (( XXX-FETCH-FILE ))
    (( XXX-LINE-NUM => SETDANCE ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( ENTERPLS ))
    (( FREE-CLS ))
    (( && ))
  )) OK)
(LET XXX-FUNCTR-U BE (( ))
  ((
    (( XXX-CASE-SCAN => FLAGFLIP ))
  )) OK)
(LET XXX-FUNCTR-W BE (( ))
  ((
    (( XXX-WORDWRAPPING => FLAGFLIP ))
  )) OK)
(LET XXX-FUNCTR-L BE (( ))
  ((
    (( XXX-RECENT-SCAN-REPL-WARP => VISBASIS
      (MATCHED
        (( EXIT ))
      MATCHED) ))
    (( FREE-CLS ; CRLN ; CRLN ))
    (( }MOVING AHEAD ONE!} => SPOP ))
    (( CRLN ; CRLN ; CRLN ))
    (( XXX-EDIT-X >>> ; 77 => INTGREATER
      (MATCHED
        (( XXX-MAX-LINE-USED >>> ; XXX-LINE-NUM >>> => INTGREATER
          (MATCHED
            (( XXX-LINE-NUM => INCVAR ))
            (( XXX-LINE-NUM >>>
              XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
            (( XXX-LINE-POS => SETDANCE ))
            (( 2 ; XXX-EDIT-X <<ASSERT ))
          MATCHED)
      )(OTHER
        (( XXX-LINE-POS => INCVAR ))
        (( XXX-EDIT-X => INCVAR ))
      MATCHED)
    (( XXX-RECENT-SCAN-REPL-WARP >>> H ))
    (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNCTR-I BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-RIGHTER-2 ))
    (( 2 XXX-LINE-POS => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNSHIFT-IND BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-RIGHTER-4 ))
    (( 4 XXX-LINE-POS => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNCTR>-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-RIGHTER-10 ))
    (( 10 XXX-LINE-POS => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNCTR<-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-LEFTER-10 ))
    (( -10 XXX-LINE-POS => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-MAX-LINE-USED-AT-LEAST-THIS BE (( >N6 ))
  ((
    (( XXX-WORK-SPACE >>> => & ))
    (( N6 ; 1 ; XXX-TOP-LINE-NUM >>> => SET-RANGE => >N6 ))
    (( XXX-MAX-LINE-USED >>> => >N7 ))
    (( N6 ; N7 => INTGREATER
      (MATCHED
        (( N6 ; N7 => SUB
          (COUNT
            (( 32 ; 1 ; (( N1 ; N9 => ADD )) ; # => PM ))
          COUNTUP) ))
        (( N6 XXX-MAX-LINE-USED <<ASSERT ))
      MATCHED) ))
    (( && ))
  )) OK) 
(LET XXX-FUNV-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-Y >>> ; 21 => INTGREATER
      (MATCHED
        (( XXX-MAX-LINE-USED >>> ; XXX-LINE-NUM >>> => INTGREATER ))
          (MATCHED
            (( XXX-LINE-NUM => INCVAR ))
            (( XXX-LINE-NUM >>> =>
              XXX-MAX-LINE-USED-AT-LEAST-THIS ))
            (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => INCVAR ))
            (( XXX-STD-FRAME ))
            (( XXX-REDISPLAY-ALL-TEXT-HERE ))
          MATCHED) ))
      )(OTHER
        (( XXX-EDIT-NEXTER ))
        (( XXX-LINE-NUM => INCVAR ))
        (( XXX-EDIT-RANGE-CONTROL ))
        (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
      MATCHED)
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUN<-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-LEFTER ))
    (( -1 ; XXX-LINE-POS => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
 )) OK)
(LET XXX-FUN^-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( (( XXX-EDIT-Y >>> ; 2 => EQN ))
      (( XXX-LINE-NUM >>> ; 1 => INTGREATER ))
      => AND
      (MATCHED
        (( -1 XXX-LINE-NUM => ADDVAR ))
        (( -1 XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => ADDVAR ))
        (( XXX-STD-FRAME ))
        (( XXX-REDISPLAY-ALL-TEXT-HERE ))
        (( XXX-UNDERLINECURRENT-POS ))
      )(OTHER
        (( XXX-EDIT-UPPER ))
        (( -1 ; XXX-LINE-NUM => ADDVAR ))
        (( XXX-EDIT-RANGE-CONTROL ))
        (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
        (( XXX-UNDERLINECURRENT-POS ))
      MATCHED)
  )) OK)
(LET XXX-FUN>-ARROW BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-EDIT-RIGHTER ))
    (( XXX-LINE-POS => INCVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNF1 BE (( ))
  ((
    (( XXX-LOAD-NEW-FILE ))
    (( CLEAR_KEYBUF ))
    (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNF2 BE (( ))
  ((
    (( XXX-STORE-FILE-OPTION ))
    (( CLEAR_KEYBUF ))
    (( XXX-REFRESH ))
  )) OK)
(LET XXX-SCAN-ACTION-ESSENCE BE (( ))
  ((
    (( V10 => NOZ
      (MATCHED
        (( V10 => TOV2 ))
        (( V10 ; V3 ; # => GM => TOV11 ))
        (( 0 => TOV10 ))
      MATCHED) ))
    (( V8 ; V11 => INTEQUAL
      (MATCHED
        (( V7 => %LENGTH => DEC
          (COUNT
            (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A
              (MATCHED
                (( ; N1 => INC ; V7 => %GET => NOT_INTEQUAL
                  (MATCHED RMS RMS GOFORWARD3 MATCHED) ))
              )(OTHER RMS RMS GOFORWARD4 MATCHED) ))
          COUNTUP) ))
        (( V2 ; XXX-LINE-POS <<ASSERT ))
        (( V2 => INC ; XXX-EDIT-X <<ASSERT ))
        (( V3 ; XXX-LINE-NUM <<ASSERT ))
        (( V3 ; XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( 2 ; XXX-EDIT-Y <<ASSERT ))
        (( V5 => INC => TOV2 ))
        (( 1 => TOV4 ))
        (( CRLN ))
        (( }* * * * * * * * * * * * * * FOUND IT!} => SPOP ))
        (( }* * * * * * $ * * * * * * * FOUND IT!} => SPOP ))
        (( }* * * * * * * * * * * * * * FOUND IT!} => SPOP ))
        (( EXIT ))
        (( GOLABEL3: ))
        (( GOLABEL4: ))
      MATCHED) ))
  )) OK)
(LET XXX-SCAN-ACTION BE (( ))
  ((
    (( }SCANNING THE TEXT >>>>CASE-EXACT<<<<!} => SPOP ))
    (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => SPOP ))
    (( }>>} => ( ))
    (( XXX-SCAN-ARRAY >>> => ARRAY>STR => POP ))
    (( VLOTS ))
      (( XXX-LINE-POS >>> => TOV10 ))
      (( XXX-LINE-NUM >>> => TOV3 ))
      (( XXX-MAX-LINE-USED >>> => TOV4 ))
      (( XXX-SCAN-ARRAY >>> => TOV7 ))
      (( 1 ; V7 => %GET => TOV8 ))
      (( VFREE ))
    (( XXX-SCAN-ACTION-HOUSE >>> ; XXX-WORK-SPACE >>> => FORVPM2 ))
    (( CRLN ; CRLN ;
    (( }DONE!} => SPOPS ))
    (( A-KEY ))
  )) OK)
(( }XXX-SCAN-ACTION-ESSENCE} => ? XXX-SCAN-ACTION-HOUSE <<ASSERT ))
(LET XXX-SCAN-ACTION-UPC-ESSENCE BE (( ))
  ((
    (( V10 => NOZ
      (MATCHED
        (( V10 => TOV2 ))
        (( V10 ; V3 ; # => GM => TOV11 ))
        (( 0 => TOV10 ))
      MATCHED) ))
    (( V8 ; V11 => UPCNUM => INTEQUAL
      (MATCHED
        (( V7 => %LENGTH => DEC
          (COUNT
            (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A
              (MATCHED
                  (( ; => UPCNUM ;
                  N1 => INC ; V7 => %GET => NOT_INTEQUAL
                  (MATCHED RMS RMS GOFORWARD3 MATCHED) ))
              )(OTHER RMS RMS GOFORWARD4 MATCHED) ))
          COUNTUP) ))
        (( V2 ; XXX-LINE-POS <<ASSERT ))
        (( V2 => INC ; XXX-EDIT-X <<ASSERT ))
        (( V3 ; XXX-LINE-NUM <<ASSERT ))
        (( V3 ; XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( 2 ; XXX-EDIT-Y <<ASSERT ))
        (( V5 => INC => TOV2 ))
        (( 1 => TOV4 ))
        (( CRLN ))
        (( }* * * * * * * * * * * * * * FOUND IT!} => SPOP ))
        (( }* * * * * * $ * * * * * * * FOUND IT!} => SPOP ))
        (( }* * * * * * * * * * * * * * FOUND IT!} => SPOP ))
        (( EXIT ))
        (( GOLABEL3: ))
        (( GOLABEL4: ))
      MATCHED) ))
  )) OK)
(LET XXX-SCAN-ACTION-UPC BE (( ))
  ((
    (( }SCANNING THE TEXT >>>>CASE-LIBERAL<<<<!} => SPOP ))
    (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => SPOP ))
    (( }>>} => ( ))
    (( XXX-SCAN-ARRAY >>> => ARRAY>STR => POP ))
    (( VLOTS ))
      (( XXX-LINE-POS >>> => TOV10 ))
      (( XXX-LINE-NUM >>> => TOV3 ))
      (( XXX-MAX-LINE-USED >>> => TOV4 ))
      (( XXX-SCAN-ARRAY >>> => TOV7 ))
      (( 1 ; V7 => %GET => TOV8 ))
      (( VFREE ))
    (( XXX-SCAN-ACTION-UPC-HOUSE >>> ; XXX-WORK-SPACE >>> => FORVPM2 ))
    (( CRLN ; CRLN ;
    (( }DONE!} => SPOPS ))
    (( A-KEY ))
  )) OK)
(( }XXX-SCAN-ACTION-UPC-ESSENCE} => ? XXX-SCAN-ACTION-UPC-HOUSE <<ASSERT ))
(LET XXX-REPL-ACTION-ESSENCE BE (( ))
  ((
    (( V10 => NOZ
      (MATCHED
        (( V10 => TOV2 ))
        (( V10 ; V3 ; # => GM => TOV11 ))
        (( 0 => TOV10 ))
      MATCHED) ))
    (( V8 ; V11 => INTEQUAL
      (MATCHED
        (( V7 => %LENGTH => DEC
          (COUNT
            (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A
              (MATCHED
                (( ; N1 => INC ; V7 => %GET => NOT_INTEQUAL
                  (MATCHED RMS RMS GOFORWARD3 MATCHED) ))
              )(OTHER RMS RMS GOFORWARD4 MATCHED) ))
          COUNTUP) ))
        (( V2 ; XXX-LINE-POS <<ASSERT ))
        (( V2 => INC ; XXX-EDIT-X <<ASSERT ))
        (( V3 ; XXX-LINE-NUM <<ASSERT ))
        (( V3 ; XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( 2 ; XXX-EDIT-Y <<ASSERT ))
        (( V5 => INC => TOV2 ))
        (( 1 => TOV4 ))
        (( XXX-LINE-NUM >>> ; XXX-WORK-SPACE >>> => %GET => >N7 )) 
        (( XXX-LINE-POS >>> ;  
          XXX-SCAN-ARRAY >>> => %LENGTH ; 
          N7 ; XXX-REPL-ARRAY >>> => REPLACE-SEGMENT )) 
        (( XXX-FILE-SHOULD-BE-STORED => SETDANCE )) 
        (( }* * * * * * * * * * * * * * REPLACED IT!} => POP ))
        (( }* * * * * * $ * * * * * * * REPLACED IT!} => POP ))
        (( }* * * * * * * * * * * * * * REPLACED IT!} => POP ))
        (( EXIT ))
        (( GOLABEL3: ))
        (( GOLABEL4: ))
      MATCHED) ))
  )) OK)
(LET XXX-REPL-ACTION BE (( ))
  ((
    (( }SCANNING THE TEXT >>>>CASE-EXACT<<<< FOR REPLACE!} => POP ))
    (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => POP ))
    (( }"} ;
      XXX-SCAN-ARRAY >>> => ARRAY>STR ;
      }"} => CONCAT => CONCAT => POP )) 
    (( VLOTS ))
      (( XXX-LINE-POS >>> => TOV10 ))
      (( XXX-LINE-NUM >>> => TOV3 ))
      (( XXX-MAX-LINE-USED >>> => TOV4 ))
      (( XXX-SCAN-ARRAY >>> => TOV7 ))
      (( 1 ; V7 => %GET => TOV8 ))
      (( VFREE ))
    (( XXX-REPL-ACTION-HOUSE >>> ; XXX-WORK-SPACE >>> => FORVPM2 ))
    (( }**** DONE! ****} => POP ))
    (( A-KEY ))
  )) OK)
(( }XXX-REPL-ACTION-ESSENCE} => ? XXX-REPL-ACTION-HOUSE <<ASSERT ))
(LET XXX-REPL-ACTION-UPC-ESSENCE BE (( ))
  ((
    (( V10 => NOZ
      (MATCHED
        (( V10 => TOV2 ))
        (( V10 ; V3 ; # => GM => TOV11 ))
        (( 0 => TOV10 ))
      MATCHED) ))
    (( V8 ; V11 => UPCNUM => INTEQUAL
      (MATCHED
        (( V7 => %LENGTH => DEC
          (COUNT
            (( (( N1 ; V2 => ADD )) ; V3 ; # => GM => A
              (MATCHED
                  (( ; => UPCNUM ;
                  N1 => INC ; V7 => %GET => NOT_INTEQUAL
                  (MATCHED RMS RMS GOFORWARD3 MATCHED) ))
              )(OTHER RMS RMS GOFORWARD4 MATCHED) ))
          COUNTUP) ))
        (( V2 ; XXX-LINE-POS <<ASSERT ))
        (( V2 => INC ; XXX-EDIT-X <<ASSERT ))
        (( V3 ; XXX-LINE-NUM <<ASSERT ))
        (( V3 ; XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( 2 ; XXX-EDIT-Y <<ASSERT ))
        (( V5 => INC => TOV2 ))
        (( 1 => TOV4 ))
        (( XXX-LINE-NUM >>> ; XXX-WORK-SPACE >>> => %GET => >N7 ))
        (( XXX-LINE-POS >>> ; 
          XXX-SCAN-ARRAY >>> => %LENGTH ;
          N7 ; XXX-REPL-ARRAY >>> => REPLACE-SEGMENT ))
        (( XXX-FILE-SHOULD-BE-STORED => SETDANCE )) 
        (( }* * * * * * * * * * * * * * REPLACED IT!} => POP ))
        (( }* * * * * * $ * * * * * * * REPLACED IT!} => POP ))     
 
        (( }* * * * * * * * * * * * * * REPLACED IT!} => POP ))
        (( EXIT ))
        (( GOLABEL3: ))
        (( GOLABEL4: ))
      MATCHED) ))
  )) OK)
(LET XXX-REPL-ACTION-UPC BE (( ))
  ((
    (( }SCANNING THE TEXT >>>>CASE-LIBERAL<<<< REPLACE!} => POP ))
    (( }SCANNING FROM PRESENT POSITION ONWARDS FOR:} => POP ))
    (( }"} ;
      XXX-SCAN-ARRAY >>> => ARRAY>STR ;
      }"} => CONCAT => CONCAT => POP )) 
    (( VLOTS ))
      (( XXX-LINE-POS >>> => TOV10 ))
      (( XXX-LINE-NUM >>> => TOV3 ))
      (( XXX-MAX-LINE-USED >>> => TOV4 ))
      (( XXX-SCAN-ARRAY >>> => TOV7 ))
      (( 1 ; V7 => %GET => TOV8 ))
      (( VFREE ))
    (( XXX-REPL-ACTION-UPC-HOUSE >>> ; XXX-WORK-SPACE >>> => FORVPM2 ))
    (( }**** DONE! ****} => POP ))
    (( A-KEY ))
  )) OK)
(( }XXX-REPL-ACTION-UPC-ESSENCE} => ? XXX-REPL-ACTION-UPC-HOUSE <<ASSERT )) 
(LET XXX-FUNF3 BE (( ))
  ((
    (( FREE-CLS ))
    ((
} HERE YOU CAN >>>>REPLACE<<<< ANY SIMPLE TEXT PATTERN WITH ANOTHER.}
      => POP ))
    ((
} -- STARTING FROM WHERE THE TEXT MARKER IS POSITIONED NOW,}
      => POP ))
    ((
} AND -- IF YOU PRESS CTR-L YOU CAN LOOP MOST RECENT SCAN/REPL,}
      => POP ))
    ((
} BUT CTR-L IS SOMETHING YOU PRESS WHEN THE TEXT IS SHOWING.}
      => POP ))
    ((
} ONCE YOU HAVE PRESSED THIS KEY, YOU MUST TYPE IN TEXT --}
      => POP ))
    ((
} -- OR PRESS ENTER TO GET A LINE/WORD WHICH YOU HAVE [INS]-MARKED}
      => POP ))
    ((
} TO SEARCH FOR. YOU WILL BE ASKED WHETHER YOU'RE CERTAIN TO GO AHEAD.}
      => POP ))
    ((
} DURING ORDINARY TEXT VIEWING MODE, CTR-U SHIFTS SCAN CASE-SENSITIVITY.}
      => POP ))
    ((
} THE TEXT SCAN/REPL IS IN MODE:}
      => POPS ))
    (( XXX-CASE-SCAN => VISDANCE
      (MATCHED
        (( }>>>>UP/LCASE-STRICT} => POP ))
      )(OTHER
        (( }>>>>UP/LCASE-LIBERAL} => POP ))
      MATCHED) ))
    ((
} TEXT TO MATCH FOR: (OR ENTER FOR FIRST LINE OF ANY RECENT [INS] CLIP)}  
      => POP ))
    (( } ==>} => ( ))
    (( READLN => TOSTANDARDSPACE => LENGTH => ISBASIS
      (MATCHED
        (( RM ))
        (( XXX-REQUEST-CLIPBOARD-FIRST-LINE ; ))
      MATCHED) ))
    (( ; => LENGTH => ISBASIS
      (MATCHED
        (( RM ))
        (( GOFORWARD4 ))
      MATCHED) ))
    (( FREE-CLS ))
    (( XXX-CASE-SCAN => VISBASIS
      (MATCHED
        (( ; => UPCM ; ))
      MATCHED) ))
    (( ; XXX-SCAN-ARRAY >>> => STR>EXISTING-ARRAY ))
    (( } EXACT TEXT TO REPLACE THIS WITH (ENTERING NOTHING MEANS REMOVE):}
      => POP ))
    (( } ==>} => ( ))
    (( READLN => TOSTANDARDSPACE ; ))
    (( ; XXX-REPL-ARRAY >>> => STR>EXISTING-ARRAY ))
    ((
} ****** ONLY ONE REPLACE WILL BE DONE. CTR-L REPEATEDLY FOR MORE.}
      => POP ))
    ((
} =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES ===========>}
 
      => POP ))
    ((
} ************* PLEASE   S A V E   FIRST IF UNCERTAIN!!!! (TYPE N HERE)}
      => POP ))
    ((
} ****  A B S O L U T E L Y   SURE TO DO  R E P L A C E?}
      => POP ))
    (( YNIN
      (MATCHED
        (( XXX-CASE-SCAN => VISDANCE
          (MATCHED
            (( }XXX-REPL-ACTION} => ? 
              XXX-RECENT-SCAN-REPL-WARP <<ASSERT ))
            (( XXX-REPL-ACTION ))
          )(OTHER
            (( }XXX-REPL-ACTION-UPC} => ? 
              XXX-RECENT-SCAN-REPL-WARP <<ASSERT ))
            (( XXX-REPL-ACTION-UPC ))
          MATCHED) ))
      MATCHED) ))
    (( GOLABEL4: ))
      (( MANUAL-CLEAR-KEYBUF ))
      (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNF4 BE (( ))
  ((
    (( FREE-CLS ))
    (( CRLN ))
    ((
} HERE YOU CAN SCAN FOR ANY SIMPLE TEXT MATCH}
      => POP ))
    ((
} -- STARTING FROM WHERE THE TEXT MARKER IS POSITIONED NOW,}
      => POP ))
    ((
} AND -- IF YOU PRESS CTR-L YOU CAN LOOP MOST RECENT SCAN/REPL,}
      => POP ))
    ((
} BUT CTR-L (LOOK) IS SOMETHING YOU PRESS WHEN THE TEXT IS SHOWING.}
      => POP ))
    ((
} ONCE YOU HAVE PRESSED THIS KEY, YOU MUST TYPE IN TEXT --}
      => POP ))
    ((
} -- OR PRESS ENTER TO GET A LINE/WORD WHICH YOU HAVE [INS]-COPIED}
      => POP ))
    ((
} TO SEARCH FOR. THE TEXT SCAN/REPL IS NOW IN MODE:}
      => POPS ))
    (( XXX-CASE-SCAN => VISDANCE
      (MATCHED
        (( }>>>>UP/LCASE-STRICT} => POP ))
      )(OTHER
        (( }>>>>UP/LCASE-LIBERAL} => POP ))
      MATCHED) ))
    ((
} CLICK CTR-U DURING ORDINARY TEXT VIEWING MODE TO SWITCH BETWEEN}
      => POP ))
    ((
} HAVING SCAN/REPL CASE SENSITIVE OR MATCHING ON BOTH CASES.}
      => POP ))
    (( CRLN ; CRLN ))
    ((
} TEXT TO MATCH FOR: (OR ENTER FOR WORDS FROM RECENT CLIPBOARD IF ANY)}
      => POP ))
    (( } ==>} => ( ))
    (( READLN => LENGTH => ISBASIS
      (MATCHED
        (( RM ))
        (( XXX-REQUEST-CLIPBOARD-FIRST-LINE ; ))
      MATCHED) ))
    (( ; => TOSTANDARDSPACE ; ))
    (( ; => LENGTH => ISBASIS
      (MATCHED
        (( RM ))
        (( GOFORWARD4 ))
      MATCHED) ))
    (( FREE-CLS ; CRLN ; CRLN ))
    (( XXX-CASE-SCAN => VISDANCE
      (MATCHED
       (( ; XXX-SCAN-ARRAY >>> ; STR>EXISTING-ARRAY ))
       (( }XXX-SCAN-ACTION} => ? XXX-RECENT-SCAN-REPL-WARP <<ASSERT ))
       (( XXX-SCAN-ACTION ))
      )(OTHER
       (( ; => UPCM ; XXX-SCAN-ARRAY >>> ; STR>EXISTING-ARRAY ))
       (( }XXX-SCAN-ACTION-UPC} => ? XXX-RECENT-SCAN-REPL-WARP <<ASSERT ))
       (( XXX-SCAN-ACTION-UPC ))
      MATCHED) ))
    (( GOLABEL4: ))
      (( MANUAL-CLEAR-KEYBUF ))
      (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNCTR-F4 BE (( ))
  ((
  )) OK)
(LET XXX-FUNF5 BE (( ))
  ((
    (( XXX-MAX-LINE-USED >>> ;
      XXX-LINE-NUM >>> => INC => INC => INTGREATER => NOT  
      (MATCHED
        (( FREE-CLS ))
        (( }FOR ESSENCE NUM REASONS, PROTECTING LIMITS OF FILE:} ;
          => POP ))
        (( }HAVE A COUPLE LINES AFTER THE INSERTION POINT.} ;
          => POP ))
        (( }THEN TRY AGAIN! THANKS} ;
          => POP ))
        (( ENTERPLS ))
        (( FREE-CLS ))
        (( XXX-REFRESH ))
        (( EXIT ))
       MATCHED) ))
    (( XXX-LINE-NUM >>> => INC =>
      XXX-MAX-LINE-USED-AT-LEAST-THIS ))
    (( XXX-FUNV-ARROW ))
    (( XXX-LINE-NUM >>> => INC =>
      XXX-MAX-LINE-USED-AT-LEAST-THIS ))
    (( XXX-FUNV-ARROW ))
    (( XXX-LINE-NUM >>> => INC =>
      XXX-MAX-LINE-USED-AT-LEAST-THIS ))
    (( XXX-FUNV-ARROW ))
    (( XXX-FUN^-ARROW ))
    (( XXX-FUN^-ARROW ))
    (( XXX-FUN^-ARROW ))
    (( XXX-MARKING-ON => VISBASIS
      (MATCHED
        (( XXX-COMPLETE-MARKING-ON ))
        (( XXX-PUT-IT-GOOD ))
        (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
        (( XXX-REFRESH ))
      )(OTHER
        (( XXX-COMPLETE-MARKING-ON ))
        (( XXX-REFRESH ))
      MATCHED) ))
    (( XXX-REFRESH-HORISONTALS ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNCTR-F5 BE (( ))
  ((
  )) OK)
(LET XXX-FUNF6 BE (( ))
  ((
    (( FREE-CLS ))
    ((
} ===INFO=ON=THE=XXXLT=TYPEWRITER! /// THE PRESENT FILENAME:}
      => POPS ))
    (( XXX-DOC-NAME => VARSTR> => POP ))
    ((
} USE CTR WITH ARROWS TO GO FASTER ON A LINE.                       ========}
      => POP ))
    ((
} WHEN YOU PRESS THE FUNCTION KEY F9 DURING TYPING,              }
      => POPS ))
    (( XXX-READ-ONLY-VAR => VISDANCE
      (MATCHED
        (( }READ-ONLY} => POP ))
      )(OTHER
        (( CRLN ))
      MATCHED) ))
    ((
} THE LINE NUMBER AND THE POSITION IN THE LINE IS SHOWN}
      => POPS ))
    (( }    CHK B9 FOR CTR-KEYS} => POP ))
    ((
} TO THE RIGHT AT F9.  THIS XXXLT (lite) EDITOR HANDLES UP TO 7500 LINES.}
      => POP ))
    ((
} YOU CAN HOWEVER PRESS F1..F8 AT ANY TIME WITHOUT PRESSING F9 FIRST.}
      => POP ))
    ((
} GET A FILE IN BY F1, STORE IT BY F2. YOU MARK TEXT BY CLICKING 'INS'}
      => POP ))
    ((
} KEY THEN MOVING. ARROWS, PGU, PGN. CTR-PGU/PGN FOR START/COMPLETION.}
      => POP ))
    ((
} THE COMPLETION OF MARKING OF TEXT IS BY CLICK 'INS' AGAIN. THEN YOU CAN}
      => POP ))
    ((
} PUT (F5) IT. YOU CAN PUT IT AS MANY TIMES AS YOU LIKE.}
      => POP ))
    ((
} THEN MOVE TEXT POSITION MARKER TO WHERE YOU WANT IT INSERTED, PRESS F5.}
      => POP ))
    ((
} CAREFULLY MARK TEXT WITH [INS], MOVE TEXT-MARKER MAX 270 LINES, AND CLICK}
      => POP ))
    ((
} [INS] TO COMPLETE. TEXT IS ONLY MARKED UNTIL NEXT TIME YOU CLICK [INS]!}
      => POP ))
    ((
} (IF YOU ARE CAREFUL TO PRESERVE THE F5 CONTENT, YOU CAN OPEN ANOTHER}
      => POP ))
    ((
} FILE WITH F1 AND PASTE IT IN THERE. YOU CAN ALSO SPECIFY A NEW FILE}
      => POP ))
    ((
} NAME -- ONE THAT YOU CREATE -- IN ORDER TO CLEAR THE DOCUMENT, WITH F1.}
      => POP ))
    ((
} THEN YOU CAN PASTE IT IN THERE. [INS]-MARK MAX  270  LINES EACH TIME.)}
      => POP ))
    ((
} USE CTR-W FOR WORDWRAP WHILE TYPING IN. STORE WITH F2 BEFORE REPLACE ETC.}
      => POP ))
    ((
} SAVE OFTEN WITH F2! USE CTR-INS TO INSERT NEW LINES, CTR-DEL REMOVE MANY.}
      => POP ))
    ((
} THE PROGRAM WILL EXIT IF YOU PRESS 'ESC'; OR SHIFT TO NEW DOC BY F1. }
      => POP ))
    ((
} F4, SCAN, MEANS TEXT SEARCH; REPLACE BY F3.  KEYTAB MOVES 2 (TRY SHIFT).}
      => POP ))
    ((
} MOST RECENT REPLACE (OR SCAN) CAN BE LOOPED BY CTR-L. SAVE FIRST!}
      => POP ))
    (( TEXT-CLR-KEY ))
    (( XXX-REFRESH ))
  )) OK)
(LET XXX-ENSURE-NOZ-EARLIER-ON-THIS-LINE BE (( >N7 >N6 ))
  ((
    (( 2 ; N6 => INTGREATER = EXIT === ))
    (( N7 ; XXX-WORK-SPACE >>> %GET => & ))
    (( N6
      (COUNT
        (( N1 ; # => %GET => ISBASIS
          (MATCHED
            (( 32 ; N1 ; # => %PUT ))
          MATCHED) ))
      COUNTUP) ))
    (( && ))
  )) OK)
(LET XXX-INSERT-ROOM-FOR-ANOTHER-RIGHT-HERE BE (( ))
  ((
    (( XXX-LINE-NUM >>> ; XXX-MAX-LINE-USED >>> => INTGREATER
      = EXIT === ))
    (( XXX-LINE-NUM >>> ; XXX-WORK-SPACE >>> => %GET => & ))
    (( # => ACTIVE-LENGTH => >N5 ))
    (( XXX-LINE-POS >>> => >N8 ))
    (( N8 ; N5 => INTGREATER
      (MATCHED
        (( N8 ; XXX-LINE-NUM >>> =>
          XXX-ENSURE-NOZ-EARLIER-ON-THIS-LINE ))
      MATCHED) ))
    (( XXX-PAGE-WIDTH >>> ; N8 => EQN
      (MATCHED
        (( 32 ; N8 ; # => %PUT ))
        (( && ))
        (( EXIT ))
      MATCHED) ))
    (( N5 => INC ; N8 => EQN
      (MATCHED
        (( 32 ; N8 ; # => %PUT ))
        (( && ))
        (( EXIT ))
      MATCHED) ))
    (( N5 ; N8 => SUB => INC => >N9 ))
    (( N5 => INC ; XXX-PAGE-WIDTH >>> => INTGREATER
      (MATCHED
        (( DECN9 ))
      MATCHED) ))
    (( (( N8 => MUL4 ; # => ADD )) ;
      (( N8 => INC => MUL4 ; # => ADD )) ;
      N9 => COPYNUMSHIGH ))
    (( 32 ; N8 ; # => %PUT ))
    (( && ))
  )) OK)
(LET XXX-FUNCTR-F6 BE (( ))
  ((
  )) OK)
(LET XXX-FUNF7 BE (( ))
  ((
  )) OK)
(LET XXX-FUNF8 BE (( ))
  ((
    (( FREE-CLS ))
    (( CRLN ))
    ((
} HERE ONE CAN JUMP TO ANYWHERE.}
      => POP ))
    ((
} IT'S FUN TO WARP.}
      => POP ))
    ((
    (( CRLN ; CRLN ; CRLN ; CRLN ; CRLN ))
    ((
} LINE NUMBER: (OR ENTER TO RETURN)}
      => POPS ))
    (( READLN => HEAL => >N5 ))
    (( N5 ; 1 ; XXX-MAX-LINE-USED >>> => SET-RANGE => >N5 ))
    (( N5 XXX-LINE-NUM <<ASSERT ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-LINE-NUM >>>
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNF9 BE (( ))
  ((
    (( XXX-STATUS-LINE ))
    (( }F1 GET F2 STORE F3 REPL F4 SCAN}
      => POPS ))
    (( }F5 PUT F6 INFO F8 JUMP}
      => POPS ))
    (( XXX-SHOW-LINE-NUM-AND-POS ))
    (( XXX-CLARIFY-STATUS-LINE => SETDANCE ))
    (( XXX-TO-CURRENT-POS ))
  )) OK)
(LET XXX-FUNINSERT BE (( ))
  ((
    (( BROWSER-MATRIX >>> => & ))
    (( XXX-CLIPBOARD-FIRST-LINE => VARSTR-SETBASIS ))
    (( XXX-CLIPBOARD-AMOUNT-LINES => SETBASIS ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-TO-CURRENT-POS ))
    (( XXX-LINE-POS >>> => >N9  ))
    (( XXX-LINE-NUM >>> => >N10 ))
    (( XXX-MARKING-ON => VISBASIS
      (MATCHED
        (( N9  ; 1 ; 3 ; # => PM ))
        (( N10 ; 2 ; 3 ; # => PM ))
        (( 0   ; 1 ; 4 ; # => PM ))
        (( 0   ; 2 ; 4 ; # => PM ))
        (( XXX-MARKING-ON => SETDANCE ))
      )(OTHER
        (( XXX-COMPLETE-MARKING-ON ))
      MATCHED) ))
    (( XXX-UNDERLINECURRENT-POS ))
    (( && ))
  )) OK)
(LET XXX-FUNDELK BE (( ))
  ((
    (( XXX-LINE-NUM >>> ; XXX-MAX-LINE-USED >>> => INTGREATER
      = EXIT === ))
    (( XXX-LINE-NUM >>> ; XXX-WORK-SPACE >>> => %GET => & ))
    (( # => ACTIVE-LENGTH => >N5 ))
    (( XXX-LINE-POS >>> => >N8 ))
    (( N8 ; N5 => INTGREATER
      = && ; EXIT === ))
    (( (( N8 => INC => MUL4 ; # => ADD )) ;
      (( N8 => MUL4 ; # => ADD )) ;
      (( N5 ; N8 => SUB )) => COPYNUMS ))
    (( 0 ; N5 ; # => %PUT ))
    (( XXX-REDISPLAY-CURRENT-LINE ))
    (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
    (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
    (( XXX-TO-CURRENT-POS ))
    (( && ))
  )) OK)
(LET XXX-FUNBP BE (( ))
  ((
    (( XXX-LINE-POS >>> ; 1 => INTGREATER
      (MATCHED
        (( XXX-FUN<-ARROW ))
        (( XXX-FUNDELK ))
      MATCHED) ))
  )) OK)
(LET XXX-NEW-LINES BE (( >N7 >N6 ))
  ((
    (( N6 ; XXX-MAX-LINE-USED >>> => INTGREATER = EXIT === ))
    (( XXX-WORK-SPACE >>> => & ))
    (( N7 ; XXX-MAX-LINE-USED >>> => ADD => >N9 ))
    (( (( XXX-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => NOZ
      (MATCHED
        (( (( N6 => INC => MUL4 ; # => ADD )) ;
        (( (( N6 => INC ; N7 => ADD )) => MUL4 ; # => ADD )) ;
        (( XXX-MAX-LINE-USED >>> ; N6 => DEC => SUB )) => COPYNUMSHIGH ))
      MATCHED) ))
    (( N7
      (COUNT
        (( XXX-PAGE-WIDTH >>> => INC => %MAKE => & ))
        (( 32 ; 1 ; # => %PUT ))
        (( GETV ; (( N1 ; N8 => ADD )) ; # => %PUT ))
      COUNTUP) ))
    (( N7 ; XXX-MAX-LINE-USED => ADDVAR ))
    (( && ))
  )) OK)
(LET XXX-FUNCTR-INS BE (( ))
  ((
    (( XXX-LINE-NUM >>> ; XXX-MAX-LINE-USED >>> => INTGTOREQUAL
      = EXIT === ))
    (( XXX-MAX-LINE-USED >>> ; XXX-TOP-LINE-NUM >>> => INTGTOREQUAL
      (MATCHED
        (( FREE-CLS ))
        (( CRLN ; CRLN ; CRLN ))
        (( } AT THE MOMENT, THE AMOUNT OF LINES IN THIS TEXT}
          => POP ))
        (( } SEEMS TO MATCH THE MAXIMUM AMOUNT OF LINES CURRENTLY}
          => POP ))
        (( } RESERVED, NAMELY 7500. THE ADVICE, WITH SUCH A GRAND TEXT}
          => POP ))
        (( } IS TO SEE IF IT IS POSSIBLE TO WORK WITH CONSIDERABLY}
          => POP ))
        (( } MORE HANDABLE SECTIONS OF IT. OR MANUALLY DELETE LINES}
          => POP ))
        (( } TO GIVE ROOM FOR MORE. THANK YOU.}
          => POP ; CRLN ))
        (( ENTERPLS ))
        (( FREE-CLS ))
        (( XXX-REFRESH ))
        (( EXIT ))
      MATCHED) ))
    (( FREE-CLS ))
    (( CRLN ))
    ((
} AFTER THE PRESENT LINE, WHICH IS LINE NUMBER}
      => POPS ))
    (( XXX-LINE-NUM >>> => POP ))
    ((
} DO YOU WANT TO INSERT A CERTAIN NUMBER OF NEW LINES?}
      => POP ))
    (( CRLN ; CRLN ))
    ((
} (THIS IS THE CTR-INS KEY; THE CONVERSE IS CTR-DEL KEY.)}
      => POP ))
    (( CRLN ; CRLN ))
    ((
} =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES ===========>}
      => POP ))
    ((
} =========> LARGER NUMBERS THAN 270 AUTOMATICALLY CORRECTED ===========>}
      => POP ))
    ((
} =========> LINES ARE CREATED   AFTER    THE PRESENT LINE ===========>}
      => POP ))
    ((
}                                vvvvv} => POP ))  
    ((
} HOW MANY LINES INSERT HERE (MAX 270)? (ENTER=GO BACK)}
      => POPS ))
    (( MANUAL-CLEAR-KEYBUF ))
    (( READLN => HEAL => >N1 ))
    (( MANUAL-CLEAR-KEYBUF ))
    (( N1 => ISBASIS = GOFORWARD4 === ))
    (( N1 ; 1 ; 270 => SET-RANGE => >N1 ))
    (( XXX-MAX-LINE-USED >>> ; N1 => ADD ; XXX-TOP-LINE-NUM >>>
      => INTGREATER
        (MATCHED
          (( CRLN ))
          (( } THIS WOULD RESULT IN A TEXT BIGGER THAN 7500 LINES.}
            => POP ))
          (( } TRY WITH A SMALLER NUMBER. CONSIDER WORKING WITH A PORTION}
            => POP ))
          (( } OF THE TEXT AT A TIME. THANK YOU.}
            => POP ))
          (( ENTERPLS ))
          (( XXX-REFRESH ))
          (( EXIT ))
        MATCHED) ))
    (( N1 => ISPRO
      (MATCHED
        (( XXX-LINE-NUM >>> ; N1 =>
          XXX-NEW-LINES ))
        (( XXX-LINE-POS => SETDANCE ))
        (( XXX-LINE-NUM >>>
          XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( XXX-EDIT-TOP-LEFT ))
        (( XXX-EDIT-RANGE-CONTROL ))
      MATCHED) ))
    (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
    (( GOLABEL4: ))
      (( XXX-REFRESH ))
  )) OK)
(LET XXX-RM-LINES BE (( >N7 >N6 ))
  ((
    (( N6 ; XXX-MAX-LINE-USED >>> => INTGREATER = EXIT === ))
    (( XXX-WORK-SPACE >>> => & ))
    (( (( N6 ; N7 => ADD => DEC )) ; XXX-MAX-LINE-USED >>> => INTGREATER
      (MATCHED
        (( XXX-MAX-LINE-USED >>> ; N6 => SUB => INC => >N7 ))
      MATCHED) ))
    (( N6 ; N7 => ADD => >N3 ))
    (( XXX-MAX-LINE-USED >>> ; N3 => SUB => INC => >N4 ))
    (( (( N3 => MUL4 ; # => ADD )) ;
      (( N6 => MUL4 ; # => ADD )) ;
      N4 => COPYNUMS ))
    (( N7 => SG ; XXX-MAX-LINE-USED => ADDVAR ))
    (( N7
      (COUNT
        (( XXX-PAGE-WIDTH >>> => INC => %MAKE ;
          (( XXX-MAX-LINE-USED >>> ; N1 => ADD )) ;
          # => %PUT ))
      COUNTUP) ))
    (( && ))
  )) OK)
(LET XXX-FUNCTR-DELK BE (( ))
  ((
    (( XXX-LINE-NUM >>> ;
      XXX-MAX-LINE-USED >>> => INTGREATER
      = EXIT === ))
    (( FREE-CLS ))
    (( CRLN ))
    (( } CTR-DEL KEY IS PRESSED.} => POP ))
    (( CRLN ))
    (( } DELETE THE PRESENT LINE, WHICH IS LINE NUMBER} => POPS ))
    (( XXX-LINE-NUM >>> => POP ))
    (( } AND A CERTAIN NUMBER OF ADDITIONAL LINES? } => POP ))
    (( CRLN ; CRLN ))
    (( } (THE CONVERSE IS CTR-INS KEY, WHICH INSERTS.)} => POP ))
    (( CRLN ; CRLN ))
    ((
} =========> PLEASE STORE OFTEN UNDER NEW NAMES WHEN BIG CHANGES ===========>}
      => POP ))
    ((
} =========> LARGER NUMBERS THAN 270 AUTOMATICALLY CORRECTED ===========>}
      => POP ))
    ((
} =========> IF UNCERTAIN, PRESS ENTER THEN SAVE WITH F2   ===========>}
      => POP ))
    (( } HOW MANY LINES DELETE HERE (MAX 270)? (ENTER=GO BACK)} => POPS ))
    (( MANUAL-CLEAR-KEYBUF ))
    (( READLN => HEAL => >N1 ))
    (( MANUAL-CLEAR-KEYBUF ))
    (( N1 => ISBASIS = GOFORWARD4 === ))
    (( N1 ; 1 ; 270 => SET-RANGE => >N1 ))
    (( N1 => ISPRO
      (MATCHED
        (( XXX-LINE-NUM >>> ; N1 =>
          XXX-RM-LINES ))
        (( XXX-LINE-NUM >>> ; XXX-MAX-LINE-USED >>> => INTGREATER
          (MATCHED
            (( -1 ; XXX-LINE-NUM => ADDVAR ))
          MATCHED) ))
        (( XXX-LINE-POS => SETDANCE ))
        (( XXX-LINE-NUM >>>
          XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
        (( XXX-EDIT-TOP-LEFT ))
        (( XXX-EDIT-RANGE-CONTROL ))
      MATCHED) ))
    (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
    (( GOLABEL4: ))
      (( XXX-REFRESH ))
  )) OK)
(LET XXX-FUNENDK BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-PAGE-WIDTH >>> ; XXX-LINE-POS <<ASSERT ))
    (( XXX-EDIT-RIGHTMOST ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNPGN BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-STD-FRAME ))
    (( XXX-PAGE-LENGTH >>> ;
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>>
      => ADD ; 1 ; XXX-MAX-LINE-USED >>> => SET-RANGE
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> ;
      XXX-MAX-LINE-USED >>> => EQN
      (MATCHED
        (( XXX-PAGE-LENGTH >>> => DEC => SG ;
          XXX-MAX-LINE-USED >>> => ADD ;
          1 ; XXX-MAX-LINE-USED >>> => SET-RANGE
          XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
      MATCHED) ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>> XXX-LINE-NUM
      <<ASSERT ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-REDISPLAY-ALL-TEXT-HERE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNPGU BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-STD-FRAME ))
    (( XXX-PAGE-LENGTH >>> => SG ;
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>>
      => ADD ; 1 ; XXX-MAX-LINE-USED >>> => SET-RANGE
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>>
      XXX-LINE-NUM <<ASSERT ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-REDISPLAY-ALL-TEXT-HERE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNHOME BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-EDIT-LEFTMOST ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNF12 BE (( ))
  ((
  )) OK)
(LET XXX-FUNCTR-PGU BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-STD-FRAME ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE ))
    (( XXX-LINE-NUM => SETDANCE ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-REDISPLAY-ALL-TEXT-HERE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUNCTR-PGN BE (( ))
  ((
    (( XXX-UN-UNDERLINECURRENT-POS ))
    (( XXX-STD-FRAME ))
    (( XXX-PAGE-LENGTH >>> => DEC => SG ;
      XXX-MAX-LINE-USED >>> => ADD ;
      1 ; XXX-MAX-LINE-USED >>> => SET-RANGE
      XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN <<ASSERT ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN >>>
      XXX-LINE-NUM <<ASSERT ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-REDISPLAY-ALL-TEXT-HERE ))
    (( XXX-UNDERLINECURRENT-POS ))
  )) OK)
(LET XXX-FUN-KEYS BE (( ))
  ((
    (( KEYNUM => >N1 ))
    ((   N1 ; 116 => EQN = XXX-FUNCTR>-ARROW
      == N1 ; 115 => EQN = XXX-FUNCTR<-ARROW
      == N1 ; 80 => EQN = XXX-FUNV-ARROW
      == N1 ; 75 => EQN = XXX-FUN<-ARROW
      == N1 ; 72 => EQN = XXX-FUN^-ARROW
      == N1 ; 77 => EQN = XXX-FUN>-ARROW
      == N1 ; 59 => EQN = XXX-FUNF1
      == N1 ; 60 => EQN = XXX-FUNF2
      == N1 ; 61 => EQN = XXX-FUNF3
      == N1 ; 62 => EQN = XXX-FUNF4
      == N1 ; 97 => EQN = XXX-FUNCTR-F4
      == N1 ; 63 => EQN = XXX-FUNF5
      == N1 ; 98 => EQN = XXX-FUNCTR-F5
      == N1 ; 64 => EQN = XXX-FUNF6
      == N1 ; 99 => EQN = XXX-FUNCTR-F6
      == N1 ; 65 => EQN = XXX-FUNF7
      == N1 ; 66 => EQN = XXX-FUNF8
      == N1 ; 67 => EQN = XXX-FUNF9
      == N1 ; 82 => EQN = XXX-FUNINSERT
      == N1 ; 83 => EQN = XXX-FUNDELK
      == N1 ; 146 => EQN = XXX-FUNCTR-INS
      == N1 ; 147 => EQN = XXX-FUNCTR-DELK
      == N1 ; 79 => EQN = XXX-FUNENDK
      == N1 ; 81 => EQN = XXX-FUNPGN
      == N1 ; 73 => EQN = XXX-FUNPGU
      == N1 ; 71 => EQN = XXX-FUNHOME
      == N1 ; 134 => EQN = XXX-FUNF12
      == N1 ; 132 => EQN = XXX-FUNCTR-PGU
      == N1 ; 118 => EQN = XXX-FUNCTR-PGN
      == N1 ; 15 => EQN  = XXX-FUNSHIFT-IND
      === === === === ===
      === === === === ===
      === === === === ===
      === === === === ===
      === === === === ===
      === === === === === ))
    (( MANUAL-CLEAR-KEYBUF ))
  )) OK)
(LET XXX-ACTUAL-WORD-OVER-TO-NEXT-LINE BE (( )) 
  (( 
    (( XXX-WORK-SPACE >>> => & )) 
    (( XXX-LINE-NUM >>> => >N10 ))
    (( XXX-FUNV-ARROW ))
    (( XXX-EDIT-RANGE-CONTROL )) 
    (( XXX-FUNHOME ))
    (( XXX-UN-UNDERLINECURRENT-POS )) 
    (( XXX-LINE-NUM >>> ; N10 => EQN = && ; EXIT === ))
    (( N10 ; # => %GET => >N9 ))
    (( XXX-LINE-NUM >>> ; # => %GET => >N11 )) 
    (( N9 => ACTIVE-LENGTH => >N4 ))
    (( N4 => ISBASIS = GOFORWARD3 === ))
    (( N4 ; XXX-WORDWRAP-POS >>> => DEC => SET-MAX => >N4 ))
    (( N4 ; N9 => SEGMENT-FIND-THIS-WORD-START => >N3 ))   
    (( 2 ; N3 => INTGREATER = GOFORWARD4 === ))
    (( N4 ; N3 => SUB => INC => >N5 ))
    (( (( N9 ; N3 => MUL4 => ADD )) ; (( N11 => INC4 )) ; N5 => COPYNUMS ))
    (( N5 => INC ; N11 => NOZ-ONLY-BEFORE-N ))
    (( N3 ; N9 => NOZ-ONLY-BEFORE-N ))
    (( N5 ; XXX-LINE-POS => ADDVAR ))
    (( N5 ; XXX-EDIT-X => ADDVAR ))
    (( XXX-EDIT-RANGE-CONTROL ))
    (( GOLABEL3: ))
    (( GOLABEL4: ))
      (( XXX-REFRESH ))
      (( && )) 
  )) OK)  
(LET XXX-TYPEWRITER-NORMAL BE (( ))
  ((
    (( GOLABEL1: ))
    (( KEYNUM => >N1 ))
    (( N1 ; 32 ; 126 => WITH
      (MATCHED
        (( XXX-UN-UNDERLINECURRENT-POS ))
        (( XXX-LINE-NUM >>> =>
          XXX-MAX-LINE-USED-AT-LEAST-THIS ))
        (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
        (( XXX-INSERT-ROOM-FOR-ANOTHER-RIGHT-HERE ))
        (( N1 ; XXX-LINE-POS >>> ; XXX-LINE-NUM >>> ;
          XXX-WORK-SPACE >>> => PM ))
        (( XXX-LINE-NUM ; XXX-MAX-LINE-USED =>
          INCREASE-VAR-IF-THIS-IS-HIGHER ))
        (( XXX-PAGE-WIDTH >>> ; XXX-LINE-POS >>> => INTGREATER
          (MATCHED
            (( XXX-EDIT-X => INCVAR ))
            (( XXX-LINE-POS => INCVAR ))
          MATCHED) ))
        (( XXX-EDIT-RANGE-CONTROL ))
        (( XXX-LINE-NUM >>> => INC =>
          XXX-MAX-LINE-USED-AT-LEAST-THIS ))
        (( XXX-REDISPLAY-CURRENT-LINE ))
        (( (( XXX-LINE-POS >>> ; XXX-WORDWRAP-POS >>>                   
          => INTGTOREQUAL )) ; (( XXX-WORDWRAPPING => VISDANCE )) => AND ;
          (( 7500 ; XXX-LINE-NUM >>> => INTGREATER )) => AND
          (MATCHED 
            (( XXX-ACTUAL-WORD-OVER-TO-NEXT-LINE )) 
            (( XXX-UNDERLINECURRENT-POS ))
           MATCHED) ))
         (( XXX-LINE-NUM >>> => INC =>
           XXX-MAX-LINE-USED-AT-LEAST-THIS ))
         (( XXX-EDIT-RANGE-CONTROL ))
         (( XXX-UNDERLINECURRENT-POS ))
        )(OTHER
         (( N1 ; KEY-ENTER >>> => EQN
         (MATCHED
             (( XXX-LINE-NUM >>> => INC =>
               XXX-MAX-LINE-USED-AT-LEAST-THIS ))
             (( XXX-FUNV-ARROW ))
             (( XXX-UN-UNDERLINECURRENT-POS ))
             (( XXX-FILE-SHOULD-BE-STORED => SETDANCE ))
             (( XXX-EDIT-LEFTMOST ))
             (( XXX-LINE-POS => SETDANCE ))
             (( XXX-CLARIFY-STATUS-LINE-IF-NEED-BE ))
             (( XXX-UNDERLINECURRENT-POS ))
            )(OTHER
             (( N1 ; KEY-ESC >>> => EQN = EXIT === ))
             (( N1 => ISBASIS             = XXX-FUN-KEYS
                == N1 ; CTRL-I >>> => EQN = XXX-FUNCTR-I
                == N1 ; 8 =>  EQN         = XXX-FUNBP
                == N1 ; 21 => EQN         = XXX-FUNCTR-U
                == N1 ; 23 => EQN         = XXX-FUNCTR-W
                == N1 ; 12 => EQN         = XXX-FUNCTR-L 
                == N1 ; 20 => EQN         = XXX-FUNSHIFT-IND
                == N1 ; 4 => EQN          = 
                   FREE-CLS ;
                   A-KEY ;
                   XXX-REFRESH 
                == N1 ; 22 => EQN         = XXX-FUNF5
                == N1 ; 3 => EQN          = XXX-FUNINSERT
                == N1 ; 7 => EQN          = XXX-FUN^-ARROW
                == N1 ; 11 => EQN         = XXX-FUN>-ARROW
                == N1 ; 26 => EQN         = XXX-FUN<-ARROW
                == N1 ; 24 => EQN         = XXX-FUNPGN
                == N1 ; 14 => EQN         = XXX-FUNCTR-PGN
                == N1 ; 17 => EQN         = XXX-FUNPGU
                == N1 ; 15 => EQN         = XXX-FUNF1
                == N1 ; 19 => EQN         = XXX-FUNF2
                == N1 ; 18 => EQN         = XXX-FUNCTR-DELK
                == N1 ; 25 => EQN         = XXX-FUNCTR-INS
                == N1 ; 6 => EQN          = XXX-FUNF4
                == N1 ; 5 => EQN          = XXX-FUNF3
                == N1 ; 10 => EQN         = XXX-FUNF8 ))
              (( === === === ))
              (( === === === === === ))
              (( === === === === === ))
              (( === === === === === ))
              (( === === === === === ))
            MATCHED) ))
        MATCHED) ))
    (( GOUP1 ))
  )) OK)
(LET XXX-INIT-VARS BE (( ))
  ((
    (( XXX-CLIPBOARD-AMOUNT-LINES => SETBASIS ))
    (( 3 => %MAKE ; XXX-REFRESH-DANCERS-WITHIN <<ASSERT ))
    (( }XXX-STD-FRAME} => ? ; 1 ;
      XXX-REFRESH-DANCERS-WITHIN >>> => %PUT ))
    (( }XXX-REDISPLAY-ALL-TEXT-HERE} => ? ; 2 ;
      XXX-REFRESH-DANCERS-WITHIN >>> => %PUT ))
    (( }XXX-UNDERLINECURRENT-POS} => ? ; 3 ;
      XXX-REFRESH-DANCERS-WITHIN >>> => %PUT ))
    (( XXX-RECENT-SCAN-REPL-WARP => SETBASIS ))
    (( 79 => MAKEBL ; XXX-CLIPBOARD-FIRST-LINE => >VARSTR ))
    (( 0 ; XXX-CLIPBOARD-FIRST-LINE => VARSTR-SETLEN ))
    (( 0 ; 1 ; 3 ; BROWSER-MATRIX >>> => PM ))
    (( 0 ; 2 ; 3 ; BROWSER-MATRIX >>> => PM ))
    (( 0 ; 1 ; 4 ; BROWSER-MATRIX >>> => PM ))
    (( 0 ; 2 ; 4 ; BROWSER-MATRIX >>> => PM ))
    (( 300 => %MAKE XXX-SCAN-ARRAY <<ASSERT ))
    (( 300 => %MAKE XXX-REPL-ARRAY <<ASSERT ))
    (( 11 XXX-PAGE-LENGTH <<ASSERT ))
    (( 78 XXX-PAGE-WIDTH <<ASSERT ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( XXX-CLARIFY-STATUS-LINE => SETBASIS ))
    (( XXX-LINE-NUM => SETDANCE ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-MARKING-ON => SETBASIS ))
    (( }XXX888} ; XXX-DOC-NAME => >VARSTR ))
    (( XXX-MAX-LINE-USED => SETDANCE ))
    (( XXX-FILE-SHOULD-BE-STORED => SETBASIS ))
    (( XXX-CASE-SCAN => SETBASIS ))
  )) OK)
(LET XXX-START BE (( ))
  ((
    (( FREE-CLS ))
    (( CRLN ; CRLN ))
} Text-mode editor XXXLT -- lite (and light) version of XXX}
          => POP ))
} Written in Lisa GJ2 Fic3. Text line width max 78.}
          => POP ))
    (( XXX-INIT-VARS ))
    (( XXX-FILE-TO-START-SHOWING => VARSTR> ;
      XXX-DOC-NAME => >VARSTR ))
    (( }                    HI!!! XXXLT ALLOTS 7500 LINES..} => POP ))
    (( 79 ; XXX-TOP-CLIPBOARD-NUM >>> 8 ADD => RAM-PM 
      XXX-CLIPBOARD <<ASSERT ))
    (( }               ***RAM ALLOTTED SOON***} => POP ))
    (( 79 ; XXX-TOP-LINE-NUM >>> 15 ADD => RAM-PM 
      XXX-WORK-SPACE <<ASSERT ))
    (( }          ///YESYESYES///} => POP ))
    (( XXX-FETCH-FILE ))
    (( }             ***} => POP ))
    (( XXX-LINE-NUM => SETDANCE ))
    (( XXX-LINE-POS => SETDANCE ))
    (( XXX-TOP-OF-PAGE-LINE-NUMBER-SHOWN => SETDANCE ))
    (( XXX-EDIT-TOP-LEFT ))
    (( CLEAR_KEYBUF ))
    (( XXX-STD-FRAME ))
    (( XXX-REDISPLAY-ALL-TEXT-HERE ))
    (( XXX-UNDERLINECURRENT-POS ))
    (( XXX-TYPEWRITER-NORMAL ))
    (( XXX-MAYBE-STORE-FILE ))
    (( RAM-REFRESH ))
  )) OK)
(LET XXXLT BE (( ; ))
  ((
    (( IS-ANYTHING-ON-MAIN-STACK => NOT
      (MATCHED
        (( }XXX888} ; ))
      MATCHED) ))
    (( ; => TOSTANDARDSPACE => RMBL
      => UPCM XXX-FILE-TO-START-SHOWING => >VARSTR ))
    (( XXX-START ))
  )) OK)
(( 58 XXX-WORDWRAP-POS <<ASSERT ))
(( XXX-WORDWRAPPING => SETBASIS ))
}* THIS HASN'T LOOKSTK SO AS TO ALLOW :DOCNAME :XXXLT IN        }* 
}* GOOD LUCK WITH XXX ALWAYS!!! ARISTO, WITH L.A.H., HIS MUSES. }* 
(LET AUTOSTART BE XXXLT OK)