        page    ,132
        title   baschon : B„renarsch Bildschirm-Schoner
;
;  Copyright (c) 1988 Alan Ballard / Gero Zahn 2/1992
;
;  Neue Version: B„renarsch-Schoner: Verwendet statt der PS/2-Maschine
;  einen normalen PC mir einer Microsoft-kompatible Maus (auch 3 Tasten).
;
;  Erweiterte Version: Hotkey aktiviert den Schoner manuell
;
;  Speziell an PC-Speed / AT-Speed (C16) angepaáte Version
;  L„uft auf ST mit den genannten Maschinen und monochromem Monitor
;
;  The program stays resident only the first time it is run.  It may be reexecuted
;  to disable blanking or to change the interval.
;
;  Options are:
;    integer      - blanking time in minutes (default 1 minutes)
;    \d           - disable blanking
;    \a           - enable blanking (default)
;    \m integer   - set the "multiplex number" to use for communicating
;                   with the loaded version.
;

;  Interrupt numbers
Keyboard@  equ 09h
Keyb2int@  equ 16h
Timer@     equ 1ch
Dos@       equ 21h
Multiplex@ equ 2fh
Mouse@     equ 33h

; Multiplex function numbers
Get_Installed_State equ 0

; baschon multiplex functions
Scrnsav_Multiplex_Number equ 150       ; random choice
Scrnsav_Disable          equ 10h
Scrnsav_Enable           equ 11h
Scrnsav_Set_Interval     equ 12h

; DOS function numbers
Print_String equ 09h
Print_Char   equ 02h
Set_Int      equ 25h
Get_Int      equ 35h
TSR          equ 31h
Terminate    equ 4ch

; mouse function numbers
check_mouse  equ 00h
mouse_status equ 03h

; keyboard function numbers
key_status   equ 02h

; Miscellaneous constants
Ticks_Per_Minute equ 1092       ; 60*18.2 = one Minute
Default_Time     equ 1          ; one minute default
Max_Time         equ 30         ; 30 minute maximum (30*1092=32760)
flash_time       equ 273        ; 15*18.2 = fifteen seconds

Cr      equ     0dh
Lf      equ     0ah

True    equ     0ffh
False   equ     00h

baschon segment para 'code'
        assume  cs:baschon,ds:nothing,es:nothing
;
;  Overlay permanent data on PSP.
;
        org     05ch                    ; not supposed to change anything before this
Old_Timer     dd ?                      ; save old timer tick
Old_Multiplex dd ?                      ; save old multiplex
Old_Keyboard  dd ?                      ; save old keyboard
;
Idle_Count  dw   ?                       ; Ticks till we begin to flash
Idle_Max    dw   ?                       ; Initial ticks
flash_count dw   ?                       ; Ticks between flashes
mouse_stat  db   ?                       ; Maus vorhanden oder nicht
mouse_bx    dw   ?                       ; Maus-Buttons
mouse_cx    dw   ?                       ; X-Koordinate
mouse_dx    dw   ?                       ; Y-Koordinate

Multiplex_No db ?                       ; Multiplex number we're using
Disabled   db   ?                       ; enable/disable flag
hotkey     db   ?                       ; Bildschirm-Schoner per Hotkey?
flash_act  db   ?                       ;
inverted   db   ?                       ;

;
; Define command line in PSP...
;
        org     080h
Cmdline label   byte
        page
;  Code starts at offset 0100h for COM file.
        org     0100h                   ; beginning for .com programs
Start:  jmp     Initialize              ; initialization code is at end.

;
;  Diese Routine invertiert den ST-Bildschirm
;
;
invert  proc    near
        JMP     run

adress  DW      0fa00h,0ef00h
        EVEN                            ;68000 Code auf gerade Adresse !
ROUTINE: DB 046H,079H,0,0FFH,082H,040H  ;NOT $FF8240
         DB 04EH,075H                   ;RTS

run:    push    bx
        push    dx
        push    es
        LEA     BX,[ROUTINE]               ;Startadresse des 68000 in
        MOV     DX,CS                      ;ES:BX
        MOV     ES,DX
        MOV     DX,4                       ;AT-SPEED C16 Code CALL 68000
        PUSH    0E9H                       ;68000 Starten
        PUSHF
        CALL    DWORD PTR adress           ; Bildschirm invertieren

        mov     al,inverted                ; Inverted-Flag invertieren
        cmp     inverted,true
        je      is_invert

        mov     inverted,true              ; jetzt invertiert
        jmp     inv_end

is_invert: mov  inverted,false

inv_end: pop     es
        pop     dx
        pop     bx
        RET
invert  endp

;
;  Common processing for keyboard and mouse action.
;  Reset timeout interval; turn screen back on if it was off.
;
Action  proc    near
        push    ax                      ; save a register
        cmp     Idle_Count,0            ; have we reached zero
        jne     Reset                   ; no, just reset count

;  Count had reached zero, so we would have disabled the screen.
;  Need to turn it back on here.

        mov     flash_act,false         ; Blinker deaktivieren
        cmp     inverted,true           ; Ist der Bildschirm noch negativ?
        jne     reset                   ; N” ...
        call    invert                  ; Doch ... Also restaurieren
        mov     inverted,false          ; Jetzt ist er wieder normal

Reset:
        mov     ax,Idle_Max             ; reset count to max
        mov     Idle_Count,ax           ; ...
        pop     ax                      ; restore
        ret                             ; return

Action  endp

;
; int 09 (keyboard) enters here. In case of keyboard intercept deactivate
; flashing. Do not deactive when hotkey occured.
; Passed on to old interrupt routine in all cases.
;
keyboard proc far
        cmp     hotkey,true             ; im Hotkey-Fall nichts tun
        je      noaction
        call    Action                  ; record something happenned
noaction: jmp    Old_keyboard           ; pass it on to old routine
keyboard endp

;
; int 1ch (timer tick) enters here. If blanking enabled, decrement count
; and see if time to blank screen.
;
Timer   proc    far

        cmp     Disabled,True           ; are we active?
        jne     aktiv
        jmp     done3

aktiv:  cmp     flash_act,true          ; Blinker an?
        jne     akt2
        dec     flash_count             ; Ja ... Z„hler erniedrigen
        jnz     akt2                    ; Null erreicht?
        call    invert                  ; Ja ... invertieren und
        mov     flash_count,flash_time  ; Z„hler initialisieren

akt2:   cmp     Idle_Count,0            ; already turned off?
        je      Done                    ; ok, nothing to do

        mov     ah,key_status           ; Hotkey (Shift L/R) prfen
        int     keyb2int@
        and     al,3
        cmp     al,3                    ; Bit 0 und Bit 1 gesetzt
        jne     aktiv2                  ; N”, also weiter

        mov     hotkey,true             ; Aufruf via Hotkey
        mov     Idle_Count,1            ; Abschaltung gleich

aktiv2: dec     Idle_Count              ; subtract one...
        jnz     Done                    ; quit if still nonzero

; Count has reached zero.  Turn off the display.

        mov     flash_act,true          ; Blinker aktivieren
        call    invert                  ; schon mal invertieren
        mov     flash_count,flash_time  ; Zeit bis zum n„chsten Invertieren

DONE:
        push ax
        push bx
        push cx
        push dx

        cmp     hotkey,true            ; Hotkey-Flag gesetzt?
        jne     maus                   ; nein ... Maus prfen
        mov     ah,key_status          ; "Shift"-Tasten-Status abfragen
        int     keyb2int@
        and     al,3                   ; Wenn Shift/Shift losgelassen wird
        cmp     al,0                   ; Hotkey-Flag auf False.
        jne     done2
        mov     hotkey,false
        jmp     done2

maus:   cmp     mouse_stat,0           ; Maus berhaupt da
        je      done2                  ; Nein ... nicht prfen

        mov     ax,mouse_status        ; ja ... Mausbewegung berprfen
        Int     mouse@
        cmp     bx,mouse_bx            ; Mausbuttons prfen
        jne     do_it                  ; ja ...
        cmp     cx,mouse_cx            ; horizontale Bewegung prfen
        jne     do_it                  ; ja ...
        cmp     dx,mouse_dx            ; vertikale Bewegung prfen
        jne     do_it                  ; ja ...
        jmp     done2

do_it:  mov     mouse_bx,bx             ; Mauspositioen merken
        mov     mouse_cx,cx
        mov     mouse_dx,dx
        call    action                  ; doch !!!

Done2:  pop dx
        pop cx
        pop bx
        pop ax
done3:  jmp     Old_Timer               ; continue with other int routine.

Timer   endp
        page
;
; int 2fh (Multiplex) enters here.  This is used for communication from
; later runs of baschon program.
;
Multiplex proc far
        cmp     ah,Multiplex_No         ; is this our number?
        je      Mine                    ; yes,...
        jmp     Old_Multiplex           ; no, pass it on.

Mine:   cmp     al,Get_Installed_State  ; are we just testing?
        jne     Mine2                   ; work to do

; Set result to indicate installed.  Also, pass back our name as further
; check for someone else using the number.
        mov     al,0ffh                 ; code to say we're here
        push    ds                      ; copy ds to es
        pop     es                      ; ...
        lea     di,es:Scrnsav_Str       ; offset for our name
        iret                            ; return it to caller.

; Look for other function requests
Mine2:  cmp     al,Scrnsav_Enable
        jne     Mine3
        mov     Disabled,False          ; set enabled
        jmp     Valid

Mine3:  cmp     al,Scrnsav_Disable
        jne     Mine4
        mov     Disabled,True           ; set disabled
        jmp     Valid

Mine4:  cmp     al,Scrnsav_Set_Interval
        jne     Invalid
        mov     Idle_Max,bx             ; reset interval

Valid:  mov     al,0                    ; set success code
        iret

Invalid: mov    al,1                    ; return error code
        iret

Scrnsav_Str db "B.A.-Schoner"

Multiplex endp
        page
;
; Initialization.  Print a greeting, process the parameters, determine
; whether already loaded, then either stay resident or communicate
; with resident version.
;
Initialize proc near
        assume  ds:baschon
        push    bx                      ; save registers we use
        push    cx
        push    si
        push    di
        push    ds
        push    es
        push    dx

        push    cs                      ; copy cs to ds.
        pop     ds

        cld                             ; always want to increment

        mov     dx,offset Greeting      ; message address
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message

;
; Process the parameters. Should be integer number of minutes,
; and/or /d (disable), /e (enable), /m <int>
;
HaveVGA:
        mov     si,offset Cmdline       ; index of parameters
        lodsb                           ; pick up count and step
        mov     ah,0                    ; extend
        mov     cx,ax                   ; copy to count register
Next_Par:
        call    Skipblanks              ; find first character
        jnz     Have_Par                ; count reached zero
        jmp     End_Pars
Have_Par:
        cmp     byte ptr [si],'/'       ; option flag?
        jne     Try_Int
        inc     si                      ; step to flag char
        dec     cx                      ; decrement count
        jz      Bad_Flag                ; missing flag spec

        cmp     byte ptr [si],'d'       ; test for disable flag
        je      Disable
        cmp     byte ptr [si],'D'
        jne     Try_E                   ; not disable
Disable: mov    Par_Disable,True        ; set the flag
        inc     si                      ; step over it
        dec     cx                      ; adjust count
        jmp     Next_Par                ; and look for more pars

Try_E:  cmp     byte ptr [si],'a'       ; test for enable flag
        je      Enable
        cmp     byte ptr [si],'A'
        jne     Try_M                   ; not enable
Enable: mov     Par_Disable,False       ; set the flag
        inc     si                      ; step over it
        dec     cx                      ; adjust count
        jmp     Next_Par                ; and look for more pars

Try_M:  cmp     byte ptr [si],'m'       ; test for m flag
        je      M_Flag
        cmp     byte ptr [si],'M'
        jne     Bad_Flag                ; invalid flag
M_Flag: inc     si                      ; step over it
        dec     cx                      ; adjust count
        call    Skipblanks              ; need a following integer par
        jz      Bad_M_Flag              ; no following par
        call    GetI                    ; find a number
        jo      Bad_M_Flag              ; it overflows
        jz      Bad_M_Flag              ; it wasn't there
        cmp     ax,80h                  ; check the range
        jl      Bad_M_Flag              ; ... too small
        cmp     ax,0ffh                 ; ...
        ja      Bad_M_Flag              ; ... too big
        mov     Par_Multiplex_No,al     ; just right
        jmp     Next_Par                ; look for more

; Not a flag; should be integer number of minutes.
Try_Int:
        call    GetI                    ; find a number
        jo      Too_Big                 ; it overflowed
        jz      Bad_Par                 ; not found
        cmp     ax,Max_Time             ; is it too big?
        ja      Too_Big                 ; yes, don't allow.
        mov     Par_Minutes,ax          ; save it away
        mov     Par_Set_Interval,True   ; remember it was specified
        jmp     Next_Par                ; look for more

; Invalid flag; back up to the / character before echoing it.
Bad_Flag:
        dec     si                      ; back up one pos
        inc     cx                      ; increase count
Bad_Par: mov    dx,offset Bad_Par_Message
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message
Echo:   lodsb                           ; get next character
        cmp     al,' '                  ; stop at a blank
        je      End_Echo
        mov     dl,al                   ; and echo it
        mov     ah,Print_Char           ; ...
        int     Dos@                    ; ...
        loop    Echo
End_Echo:
        mov     dx,offset Bad_Par_Message2
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the end of the message
        jmp     Unload

Too_Big: mov    dx,offset Too_Big_Message
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message
        jmp     Unload

Bad_M_Flag:
        mov     dx,offset Bad_M_Flag_Message
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message
        jmp     Unload

        page
;
;  Parameter processing finished.
;
End_Pars:
        mov     ax,Par_Minutes          ; compute ticks required
        mul     Ticks                   ; ...
        mov     Par_Ticks,ax            ; ...

;
;  Determine whether already installed.
;
        mov     ah,Par_Multiplex_No     ; ask if already installed...
        mov     al,Get_Installed_State  ; ...
        int     Multiplex@              ; ...?
        cmp     al,0                    ; is it installed?
        je      Install                 ; no, go do it
        cmp     al,0ffh                 ; seems to be, make sure
        jne     Cant_Install            ; something wrong
;  Last test: if it is installed, should get back es:di pointing to
;  our name.
        lea     si,Scrnsav_Str
        mov     cx,size Scrnsav_Str
        repnz   cmpsb                   ; compare the bytes
        jne     Cant_Install

;
;  Seems to be already installed, so pass across requested state.
;
        mov     ah,Par_Multiplex_No     ; First set enabled/disabled.
        mov     al,Scrnsav_Enable       ; assume enabling
        cmp     Par_Disable,True        ; are we really?
        jne     Send_Enable             ; ...
        mov     al,Scrnsav_Disable      ; ... nope
Send_Enable:
        int     Multiplex@              ; Send it to resident copy.
        cmp     al,0                    ; check for problems
        jne     Cant_Change

        cmp     Par_Set_Interval,True   ; Do we want to change interval?
        jne     No_Change
        mov     ah,Par_Multiplex_No     ; yes, set up parameters
        mov     al,Scrnsav_Set_Interval ; ...
        mov     bx,Par_Ticks            ;...
        int     Multiplex@              ; Send it to resident copy.
        cmp     al,0                    ; check for problems
        jne     Cant_Change

;
; Write out what we did.
;
No_Change:
        mov     ax,offset Null_Message  ; no "installed and" part
        call    Write_Status            ; call common routine
        jmp     Unload_Ok               ; and terminate

;
; Problems
;
Cant_Install:
        mov     dx,offset Cant_Install_Message
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message
        jmp     Unload

Cant_Change:
        mov     dx,offset Cant_Change_Message
        mov     ah,Print_String         ; function code
        int     Dos@                    ; write the message
        jmp     Unload

        page

;
;  Appears to be OK to install, so lets do so.
;
Install:
        mov     al,Par_Disable          ; Set enable/disable state
        mov     Disabled,al             ; ...
        mov     ax,Par_Ticks            ; And interval
        mov     Idle_Count,ax           ; ...
        mov     Idle_Max,ax             ; ...
        mov     al,Par_Multiplex_No     ; and multiplex number
        mov     Multiplex_No,al         ; ...

;
; Set up the interrupt vectors
;
        mov     ax,check_mouse       ; wenn 0 -> Keine Mause
        mov     bx,0
        mov     cx,0
        mov     dx,0
        int     Mouse@
        mov     mouse_stat,al
        cmp     al,0
        je      weiter_i
        mov     ax,mouse_status      ; ggf. Mausstatus initialisieren
        int     Mouse@
        mov     mouse_bx,bx
        mov     mouse_cx,cx
        mov     mouse_dx,dx
        mov     hotkey,false         ; noch kein Hotkey gedrckt
        mov     flash_act,false      ; Blinker nicht aktiv
        mov     inverted,false       ; Bildschirm ist normal

weiter_i:
        mov     ah,Get_Int
        mov     al,Multiplex@           ; Get int 2f.
        int     Dos@
        mov     word ptr Old_Multiplex,bx        ; Save it away
        mov     word ptr Old_Multiplex+2,es
        mov     ah,Set_Int
        mov     al,Multiplex@           ; Set new int 2f
        mov     dx,offset Multiplex
        int     Dos@                    ; ...

        mov     ah,Get_Int
        mov     al,Timer@               ; Get int 1c
        int     Dos@
        mov     word ptr Old_Timer,bx           ; Save it away
        mov     word ptr Old_Timer+2,es
        mov     ah,Set_Int
        mov     al,Timer@               ; Set new int 1c.
        mov     dx,offset Timer
        int     Dos@                    ; ...

        mov     ah,Get_Int
        mov     al,keyboard@               ; Get int 09
        int     Dos@
        mov     word ptr Old_Keyboard,bx           ; Save it away
        mov     word ptr Old_Keyboard+2,es
        mov     ah,Set_Int
        mov     al,keyboard@               ; Set new int 09.
        mov     dx,offset keyboard
        int     Dos@                    ; ...

;
;  Put out a message saying what we did.
;
        mov     Par_Set_Interval,True   ; always include the interval
        mov     ax,offset Installed_Message
        call    Write_Status            ; call common code

;
;  Terminate and stay resident.
;
        mov     ah,TSR                  ; terminate/stay resident
        mov     al,0                    ; ... with exit code 0
        pop     dx                      ; pop this off here... we don't restore it
        mov     dx,((offset Initialize - offset baschon) + 15)/16
        jmp     Return

;  Terminate and unload (OK)
Unload_Ok:
        mov     al,00h                  ; Error code 0
        jmp     Unload2                 ; merge

;  Terminate and unload with error code.
Unload: mov     al,01h                  ; with error code 1
Unload2: mov    ah,Terminate            ; terminate
        pop     dx                      ; restore dx

Return:
        pop     es
        pop     ds
        pop     di
        pop     si
        pop     cx                      ; restore registers
        pop     bx
        int     Dos@                    ; back to DOS.
Initialize endp
        page
;
;  Write_Status writes a message saying what we did.
;
; At entry:     ax = message "installed and" if required.
;
Write_Status proc near
        push    dx                      ; save reg we clobber
        push    ax                      ; save parameter
        mov     dx,offset Status_Message ; "Screen saver "
        mov     ah,Print_String
        int     Dos@

        pop     dx                      ; "installed and "
        mov     ah,Print_String
        int     Dos@

        mov     dx,offset Enabled_Message ; "enabled"
        cmp     Par_Disable,True
        jne     Ws_Enable
        mov     dx,offset Disabled_Message ; "disabled"
Ws_Enable:
        mov     ah,Print_String
        int     Dos@

        cmp     Par_Set_Interval,True
        jne     Ws_Done

        mov     dx,offset Lpar_Message  ; " ("
        mov     ah,Print_String
        int     Dos@

        mov     ax,Par_Minutes          ; <integer>
        call    WriteI

        mov     dx,offset Rpar_Message  ; " minutes)"
        mov     ah,Print_String
        int     Dos@

Ws_Done:
        mov     dx,offset End_Message   ; "."
        mov     ah,Print_String
        int     Dos@

        pop     dx                      ; restore reg
        ret

Write_Status endp

        page
;
; Skipblanks skips over blanks and returns at non blank.
;
; At entry:   si = index of first byte to check
;             cx = count of characters in string
;
; At return:  si = index of non blank
;             cx = remaining characters
;             z bit = clear if non blank found
;                   = set if no nonblanks
;
; (Could do this with a rep scsb instruction, but setting it up
; is more hassle than its worth...)
;
Skipblanks proc near

Sb_Loop:
        cmp     cx,0                    ; any charaters left?
        je      Sb_Ret                  ; nope
        cmp     byte ptr [si],' '       ; is it blank?
        jne     Sb_Ret                  ; nope, found something
        inc     si                      ; step to next
        dec     cx                      ; decrement count
        jmp     Sb_Loop                 ; ... and continue
Sb_Ret:
        ret
Skipblanks endp
        page
;
; GetI converts an ascii string to an integer. It returns
; on encountering a non-digit.
;
; At entry:   si = index of first byte to convert
;             cx = count of characters in string
;
; At return:  si = index of first non digit
;             cx = remaining characters
;             ax = converted integer
;             o bit is set if result overflows a single register
;             z bit = clear if integer found
;                   = set if no integer
;
GetI    proc near
        push    bx
        push    dx
        push    cx                      ; copy cx for testing at end
        cmp     cx,0                    ; see if we have any characters
        jz      Gi_Ret                  ; ... and return if not.

        mov     ax,0                    ; initialize result in ax
Gi_Loop: mov    bl,[si]                 ; pick up a byte
        cmp     bl,'0'                  ; check it is in range
        jb      Gi_Ret                  ; ...
        cmp     bl,'9'                  ; ...
        ja      Gi_Ret                  ; ...
        inc     si                      ; step to next character

        mul     Ten                     ; accumulate result in ax/dx
        jo      Gi_RetO                 ; overflowed
        sub     bl,'0'                  ; convert digit to 0 ... 9
        mov     bh,0                    ; ... word value
        add     ax,bx                   ; add to result so far
        jo      Gi_RetO                 ; overflowed
        loop    Gi_Loop                 ; decrement count and continue
        jmp     Gi_Ret                  ; merge below

Gi_RetO: pop    bx                      ; pop off saved cx
        jmp     Gi_Ret2                 ; merge below

Gi_Ret: pop     bx                      ; pop back saved cx
        cmp     bx,cx                   ; and set z bit to whether we found num
Gi_Ret2: pop     dx                     ; restore regs (z or o bits set)
        pop     bx                      ; ...
        ret
GetI    endp

        page
;
; WriteI converts a positive, word, integer to characters and writes
; them to stdout.   It uses recursion to emit the digits in the
; right order.
;
; At entry:     ax = number to convert
;
WriteI  proc    near
        push    dx                      ; save reg we use
        cmp     ax,10                   ; more than one digit?
        jb      Wi_Digit                ; nope, just do the digit

        mov     dx,0                    ; extend the dividend
        div     Ten                     ; quot-> ax, rem-> dx
        call    WriteI                  ; handle the quotient
        mov     ax,dx                   ; followed by the remainder

Wi_Digit:
        add     al,'0'                  ; convert digit to char
        mov     dl,al                   ; and write it out...
        mov     ah,Print_Char
        int     Dos@

        pop     dx                      ; restore
        ret                             ; and return

WriteI  endp
        page
;
;  Data area used during option parsing.
;
Par_Disable db  False                   ; Flags for options ...
Par_Set_Interval db False               ; ... specified
Par_Multiplex_No db Scrnsav_Multiplex_Number ; default number to use
Par_Minutes dw  Default_Time            ; interval in minutes
Par_Ticks   dw  ?                       ; interval in ticks

;  Constants for mul/div instructions
Ticks   dw      Ticks_Per_Minute
Ten     dw      10

; Message emitted
Greeting db     'BASCHON - B„renarsch-Bildschirmschoner fr '
         db     'PC-Speed / AT-Speed / AT-Speed C16',Cr,Lf
         db     '(C)opyright 1988 Alan Ballard / Gero Zahn 2/1992',Cr,Lf,'$'
Bad_Par_Message db Cr,Lf,'Ungltiger Paramter: "$'
Bad_Par_Message2 db '".',Cr,Lf
        db      '   Parameter sind',Cr,Lf
        db      '      integer    (Anzahl Minuten)',Cr,Lf
        db      '      /a         (Schoner aktivieren)',Cr,Lf
        db      '      /d         (Schoner deaktivieren)',Cr,Lf
        db      '      /m integer (Multiplex-Nummer „ndern)',Cr,Lf
        db      '$'
Too_Big_Message db Cr,Lf,'Zeit zu lang.  Maximum ist 30.',Cr,Lf, '$'
Bad_M_Flag_Message db Cr,Lf,'Falsche /m-Option.  Muá von '
        db      'Zahl zwischen 128 und 255 gefolgt werden.',Cr,Lf,'$'
Cant_Install_Message db Cr,Lf,"Kann Schoner nicht installieren.  "
        db      'Andere Multiplex-Nummer (/m option) versuchen.',Cr,Lf,'$'
Cant_Change_Message db Cr,Lf,"Fehler mit installiertem Schoner.  "
        db      'Andere Multiplex-Nummer (/m option) versuchen.',Cr,Lf,'$'

Status_Message db 'Hotkey fr manuellen Schoner ist L-Shift/R-Shift',Cr,Lf
               db 'Schoner $'
Installed_Message db 'installiert und $'
Null_Message      db '$'
Enabled_Message   db 'aktiviert$'
Disabled_Message  db 'deaktiviert$'
Lpar_Message      db ' ($'
Rpar_Message      db ' Minute(n))$'
End_Message       db '.',Cr,Lf,'$'

baschon ends


        end Start
