ROZDZIAŁ 10

ATARI 800 ze zdjętą pokrywą obudowy. Widoczne karty pamięci i kartridż BASIC.

W komputerach ATARI XL/XE kartridż BASIC'a został wbudowany we wnętrzu komputera. BASIC zajmuje obszar pamięci od adresu $A000 do $BFFF. Aby uruchomić BASIC potrzebne jest co najmniej 8 KB pamięci RAM.

Aby efektywnie korzystać z języka ATARI BASIC, musisz znać jego mocne i słabe strony. Informacja ta pozwoli ci tworzyć programy wykorzystujące zalety i własności ATARI BASIC'a.

Mocne strony ATARI BASIC'a:

• Obsługuje grafikę systemu operacyjnego – proste wywołania grafiki mogą być wykonane w celu umieszczania informacji na ekranie.
• Wspiera obsługę sprzętu – wywołania takie jak SOUND, STICK i PADDLE tworzą prosty interfejs do układów sprzętowych komputera.
• Prosty interfejs dla programów w języku asemblera – funkcja USR umożliwia użytkownikowi łatwy dostęp do procedur w języku asemblera.
• Interpreter oparty na pamięci ROM – interpreter języka BASIC znajduje się w pamięci ROM, co zapobiega przypadkowej modyfikacji przez program użytkownika.
• Wsparcie dla DOS – specjalizowane wywołania takie jak NOTE i POINT (DOS 2.0S) pozwalają użytkownikowi na swobodny dostęp do dysku poprzez dyskowy system operacyjny.
• Wsparcie dla urządzeń peryferyjnych – każde urządzenie peryferyjne rozpoznawane przez system operacyjny może być dostępne z programu w języku BASIC.

Słabe strony ATARI BASIC'a:

• Brak wsparcia dla liczb całkowitych – wszystkie liczby są przechowywane jako 6-bajtowe liczby zmiennoprzecinkowe BCD.
• Wolny pakiet procedur arytmetycznych – ponieważ wszystkie liczby mają długość 6 bajtów, to operacje matematyczne stają się raczej wolne.
• Brak tablic łańcuchów znakowych – można utworzyć tylko jednowymiarowe łańcuchy.

• BASIC pobiera z wejścia wiersz od użytkownika i konwertuje go na postać stokenizowaną.
• Następnie umieszcza ten wiersz w programie.
• Ten program jest potem wykonywany.

Szczegóły tych operacji są dyskutowane w następnych czterech podrozdziałach.

1. BASIC dostaje wiersz wejściowy.
2. Sprawdza on następnie, czy wiersz ma poprawną składnię. Jeśli nie, raportowany jest błąd.
3. Podczas sprawdzania składni wiersz jest tokenizowany.
4. Stokenizowany wiersz jest umieszczany w programie.
5. Jeśli wiersz jest w trybie natychmiastowym (nie posiada numeru wiersza), to zostaje wykonany.

Aby lepiej zrozumieć proces tokenizacji, niektóre terminy muszą zostać zdefiniowane:

BASIC rozpoczyna tokenizację przez pobranie wiersza danych wejściowych. Te dane są otrzymywane z jednego ze sterowników w systemie operacyjnym. Normalnie wiersz wejściowy pochodzi z edytora ekranowego, jednakże za pomocą rozkazu ENTER można określić dowolne urządzenie. Wywołaniem używanym przez BASIC jest rozkaz odczytu rekordu, a dane są zwracane w postaci ciągu znaków ATASCII zakończonego znakiem EOL. Dane te zostają umieszczone przez CIO w buforze wejściowym wiersza BASIC od adresu $580 do $5FF.

Po zwróceniu tego rekordu rozpoczyna się proces sprawdzania składni i tokenizacji. Najpierw BASIC szuka numeru wiersza. Jeśli taki znajdzie, zamienia go na 2-bajtową liczbę całkowitą. Jeśli numer wiersza jest nieobecny, to zostaje przyjęty tryb natychmiastowy i wierszowi przydziela się numer $8000. Będą to dwa pierwsze tokeny tokenowego wiersza. Wiersz ten jest budowany w buforze wyjściowym o długości 256 bajtów przebywającym na końcu zarezerwowanej pamięci RAM systemu operacyjnego.

Następnym tokenem jest bajt zarezerwowany na zliczanie bajtów od początku tego wiersza do początku następnego wiersza. Za nim jest kolejny bajt z odległością od początku tego wiersza do początku następnego polecenia. Wartości te zostaną ustawione, gdy zakończy się tokenizacja wiersza i polecenia. Użycie tych wartości przedyskutowano w rozdziale dotyczącym procesu wykonywania programu.

Teraz BASIC szuka rozkazu dla pierwszego polecenia wiersza wejściowego. Następuje sprawdzenie poprawności tego rozkazu przez przeszukanie listy dozwolonych rozkazów w ROM. Jeśli zostanie znaleziona zgodność to następnym bajtem w kodowanym wierszu staje się numer tego elementu listy w ROM, który był zgodny. Jeśli nie stwierdzi się żadnej zgodności, to bajtowi temu przypisywany jest token błędu składniowego i BASIC przerywa tokenizację, kopiuje resztę bufora wejściowego w formacie ATASCII do bufora wyjściowego i wypisuje wiersz z błędem.

Zakładając, iż wiersz jest dobry, jeden z siedmiu elementów może wystąpić za rozkazem: zmienna, stała, operator, funkcja, cudzysłów, inne polecenie lub znak EOL. BASIC sprawdza, czy następny znak wejściowy jest numeryczny. Jeśli nie, to porównuje ten znak wraz ze znakami za nim z elementami w tablicy nazw zmiennych. Jeśli jest to pierwszy wiersz kodu wprowadzonego w programie, to nie zostanie znaleziona zgodność. Znaki te są następnie porównywane z tablicami funkcji i operatorów. Jeśli nie zostanie znaleziona żadna zgodność, to BASIC zakłada, że jest to nazwa nowej zmiennej. Ponieważ jest to pierwsza zmienna, zostaje jej przypisany pierwszy element w tablicy nazw zmiennych. Znaki zostają skopiowane z wiersza wejściowego i umieszczone w tablicy nazw z ustawionym najbardziej znaczącym bitem w ostatnim bajcie nazwy. Następnie osiem bajtów jest rezerwowane w tablicy wartości zmiennych dla tego elementu. (Zobacz na dyskusję na temat tablicy wartości zmiennych w podrozdziale "Struktura pliku tokenowego".)

Tokenem, który trafia do tokenowego wiersza jest numer zmiennej minus jeden z ustawionym najstarszym bitem. W ten sposób pierwsza wprowadzona zmienna otrzyma numer szesnastkowy $80, druga będzie miała numer $81 i tak dalej aż do $FF dla maksymalnej liczby 128 zmiennych.

Jeśli zostanie znaleziona funkcja, to tokenowi będzie przypisany numer jej wpisu w tablicy operatorów i funkcji. Funkcje wymagają pewnego ciągu parametrów; te są zawarte w tablicach składniowych, a jeśli się nie będą zgadzać, powstanie w wyniku błąd składni.

Jeśli zostanie znaleziony operator, to tokenowi będzie nadany numer jego wpisu w tablicy. Operatory mogą występować jeden za drugim w dosyć skomplikowany sposób (np. wielokrotne nawiasy), zatem sprawdzanie ich składni jest trochę złożone.

W przypadku cudzysłowu BASIC zakłada, że jest to łańcuch znakowy i nadaje wartość $0F tokenowi wyjściowemu oraz rezerwuje dodatkowy bajt na długość łańcucha. Znaki są przenoszone z bufora wejściowego do bufora wyjściowego aż do momentu, gdy zostanie znaleziony następny cudzysłów. Bajt długości zostaje wtedy ustawiony na liczbę znaków łańcucha.

Jeśli następne znaki w buforze wejściowym są numeryczne, to BASIC konwertuje je na 6-bajtową stałą BCD. Do bufora wyjściowego jest wstawiany token $0E, po którym następuje 6-bajtowa stała.

Gdy zostanie napotkany dwukropek, do bufora wyjściowego jest wstawiany token o kodzie $14, a przesunięcie od początku wiersza zostaje umieszczone w bajcie, który był zarezerwowany na liczbę bajtów do następnego polecenia. W tym punkcie rezerwowany jest kolejny bajt i proces wraca do początku, aby pobrać następny rozkaz.

Gdy zostanie znaleziony znak końca wiersza EOL, zapisywany jest token o kodzie $16, a liczba bajtów od początku wiersza umieszczana jest w zarezerwowanym do tego celu bajcie. W tym punkcie tokenizacja dobiegła końca i BASIC przenosi wiersz z kodami tokenów do programu. Najpierw poszukuje w programie numeru wiersza. Jeśli go znajdzie, to zamienia stary wiersz nowym. Jeśli go nie znajdzie, to wstawia nowy wiersz w prawidłowej kolejności. W obu przypadkach dane występujące po tym wierszu będą przesuwane w górę lub w dół pamięci, aby pozwolić na rozrost lub skurczenie się programu.

Teraz BASIC sprawdza, czy wiersz tokenowy jest wierszem w trybie natychmiastowym. Jeśli tak, wiersz zostaje wykonany zgodnie z metodami opisanymi w procesie interpretacyjnym; jeśli nie, BASIC wraca, aby pobrać następny wiersz wejściowy.

Jeśli w dowolnym momencie podczas procesu tokenizacji długość wiersza tokenowego przekroczy 256 bajtów, na ekran zostanie przesłana wiadomość o błędzie nr 14 (wiersz zbyt długi), a BASIC wróci do pobrania następnego wiersza wejściowego.

Przykładowy wiersz wejściowy oraz jego stokenizowana postać wygląda następująco (wszystkie kody tokenów są podane w systemie szesnastkowym):

10 LET X=1 : PRINT X 

Pierwszym wierszem kodu wykonywanym w programie jest wiersz trybu natychmiastowego. Zwykle zawiera on rozkaz RUN lub GOTO. W przypadku RUN BASIC przechodzi do pierwszego wiersza tokenów z tablicy pleceń (program tokenowy) i przetwarza go. Jeśli cały kod programu znajduje się w kolejnych wierszach, to BASIC po prostu przetwarza te wiersze po kolei.

Jeśli zostanie napotkany rozkaz GOTO, to musi być znaleziony wiersz, do którego należy przejść. Tablica poleceń zawiera połączoną listę stokenizowanych wierszy BASIC'a. Wiersze te są przechowywane w porządku rosnącym ich numerów. Aby znaleźć jakiś wiersz w środku tej tablicy, BASIC rozpoczyna od znalezienia pierwszego wiersza programu.

Adres pierwszego wiersza jest zawarty we wskaźniku STMTAB pod adresem $88 i $89. Adres ten zostaje teraz umieszczony w tymczasowym wskaźniku. Pierwsze dwa bajty pierwszego wiersza są jego numerem, który zostaje porównany z żądanym numerem wiersza. Jeśli ten pierwszy numer jest mniejszy, to BASIC przechodzi do następnego wiersza przez dodanie trzeciego bajtu pierwszego wiersza do tymczasowego wskaźnika, który teraz zacznie wskazywać drugi wiersz programu. Ponownie dwa pierwsze bajty tego nowego wiersza są porównywane z pożądanym numerem wiersza, a jeśli są mniejsze, trzeci bajt zostaje dodany do wskaźnika i proces się powtarza. Jeśli numer wiersza pasuje, to zawartość tymczasowego wskaźnika jest przenoszona do STMCUR i BASIC pobiera następny token z nowego wiersza. Jeśli pożądany numer wiersza nie zostanie znaleziony, generowany jest błąd ERROR 12.

GOSUB wymaga więcej przetwarzania niż GOTO. Procedura znajdowania wiersza jest taka sama, lecz zanim BASIC przejdzie do tego wiersza, tworzy element na stosie czasu wykonywania (ang. Run Time Stack). Przydziela on cztery bajty na końcu stosu i umieszcza 0 w pierwszym bajcie, aby oznaczyć na stosie element  GOSUB. Następnie umieszcza w kolejnych dwóch bajtach numer wiersza, który wykonywał, gdy napotkał rozkaz GOSUB. Ostatni bajt zawiera offset (przesunięcie) w bajtach od początku tego wiersza do miejsca, w którym znaleziono token GOSUB. Wtedy BASIC wykonuje wiersz, który wyszukał. Gdy zostanie napotkany rozkaz RETURN, element na stosie jest pobierany, a BASIC wraca do wiersza wywołującego.

Rozkaz FOR powoduje, iż BASIC rezerwuje na stosie czasu wykonania 16 bajtów. Pierwsze sześć są granicą w formacie 6-bajtowym BCD, którą może osiągnąć zmienna licznikowa. Drugie sześć bajtów zawiera wartość kroku w tym samym formacie. Po nich BASIC umieszcza numer zmiennej licznikowej z ustawionym najstarszym bitem. A na koniec umieszcza bieżący numer wiersza (dwa bajty) oraz offset w tym wierszu. Wtedy wykonywana jest reszta poleceń tego wiersza.

Gdy BASIC znajdzie rozkaz NEXT, patrzy na ostatni element na stosie. Upewnia się, iż zmienna przy NEXT jest tą samą zmienną na stosie, modyfikuje odpowiednio licznik pętli, a następnie sprawdza, czy licznik pętli osiągnął lub przekroczył granicę. Jeśli nie, to BASIC wraca do wiersza z instrukcją FOR i kontynuuje wykonanie. Jeśli granica została osiągnięta, to element FOR jest usuwany ze stosu i wykonanie jest kontynuowane od tego miejsca.

Gdy jest obliczana wartość wyrażenia, to operatory są umieszczane na stosie operatorów, po czym są kolejno pobierane ze stosu i obliczane. Kolejność umieszczania operatorów na stosie może być albo implikowana, w którym to przypadku BASIC przeszukuje tablicę kolejności operatorów umieszczoną w ROM lub kolejność może być bezpośrednio określona przez położenie nawiasów.

Naciśnięcie w dowolnej chwili klawisza BREAK powoduje, iż system operacyjny ustawia pewien znacznik, aby oznaczyć to zdarzenie. BASIC sprawdza ten znacznik po przetworzeniu każdego tokenu. Jeśli odkryje, że znacznik ten jest ustawiony, to zapamiętuje numer wiersza, w którym się to zdarzyło, wypisuje wiadomość "STOPPED AT LINE XXXX" (ZATRZYMANE W WIERSZU XXXX), zeruje znacznik BREAK i czeka na wprowadzenie danych przez użytkownika. W tym miejscu użytkownik może wpisać CONT i wykonanie programu zostanie wznowione od następnego wiersza.

ZAPIS/ODCZYT (ang. SAVE/LOAD): Gdy program tokenowy jest zapisywany na jakimś urządzeniu, zapisane zostają dwa bloki informacji. Pierwszy blok składa się z siedmiu z dziewięciu wskaźników na stronie zerowej, które BASIC używa to zarządzania plikiem tokenowym. Są to wskaźniki od LOMEM ($80,$81) do STARP ($8C,$8D). We wskaźnikach tych dokonywana jest jedna zmiana przy ich zapisie: wartość LOMEM zostaje odjęta od każdego z tych 2-bajtowych wskaźników i te ich nowe wartości zostają zapisane na danym urządzeniu. W ten sposób pierwsze dwa zapisywane bajty będą miały wartość 0,0.

Drugi zapisywany blok informacji składa się z następujących sekcji pliku tokenowego: (1) tablica nazw zmiennych, (2) tablica wartości zmiennych, (3) program tokenowy i (4) wiersz trybu natychmiastowego.

Gdy ten program jest ładowany do pamięci, BASIC patrzy na zmienną systemową MEMLO ($2E7,$2E8) i dodaje jej wartość do każdego z 2-bajtowych wskaźników ze strony zerowej, gdy są one odczytywane z urządzenia. Wskaźniki te są umieszczane z powrotem na stronie zerowej, a wtedy wartości RUNSTK ($8E,$8F) i MEMTOP ($90,$91) zostają ustawione na wartość w STARP.

Następnie w pamięci jest rezerwowane 256 bajtów ponad wartością MEMLO, aby przydzielić miejsce dla wyjściowego bufora tokenowego. Teraz zostaje wczytana informacja pliku tokenowego od obszaru tablicy nazw zmiennych do wiersza trybu natychmiastowego. Dane te są umieszczane w pamięci bezpośrednio za wyjściowym buforem tokenowym .

Przyspieszanie programu w języku BASIC

1. Zakoduj ponownie – Ponieważ BASIC w ATARI nie jest językiem strukturalnym, zapisany w nim kod jest skłonny do nieefektywności. Po wielu poprawkach sytuacja się nawet pogarsza. Dlatego warto spędzić czas na ponownym ułożeniu kodu.
2. Sprawdź logikę algorytmu – Upewnij się, iż kod wykonujący jakiś proces jest tak efektywny, jak to jest możliwe.
3. Umieść często wywoływane podprogramy i pętle FOR/NEXT na początku programu – BASIC rozpoczyna szukanie wiersza o danym numerze na początku programu, zatem odwołania do wierszy leżących na końcu zajmą więcej czasu na ich odnalezienie.
4. Dla często wykonywanych operacji w pętli używaj raczej kodu w tej pętli, a nie podprogramów – Szybkość programu można poprawić tutaj, ponieważ BASIC spędza czas na dodawaniu i usuwaniu elementów ze stosu czasu wykonania.
5. Ustaw najczęściej zmieniającą się pętle zagnieżdżonego zbioru jako najgłębszą – W ten sposób stos czasu wykonania będzie zmieniany najmniejszą liczbę razy.
6. Uprościj rachunki zmiennoprzecinkowe wewnątrz pętli – Jeśli wynik jest osiągany za pomocą mnożenia stałej przez jakiś licznik, czas można zaoszczędzić przez zmianę tej operacji na dodawanie stałej.
7. Utwórz pętle jako wielokrotne polecenia w jednym wierszu – W ten sposób interpreter języka BASIC nie będzie musiał przechodzić do następnego wiersza przy kontynuacji pętli.
8. Wyłącz wyświetlanie obrazu na ekranie – Jeśli informacja ekranowa nie jest istotna przez pewien okres czasu, to można zaoszczędzić do 30 procent czasu przez POKE 559,0.
9. Użyj szybszego trybu graficznego lub krótszej listy wyświetlania – Jeśli nie jest konieczny pełny obraz, to można zaoszczędzić do 25% czasu.
10. Użyj kodu w języku asemblera – Czas można zaoszczędzić przez zakodowanie pętli w asemblerze i użycie funkcji USR.

Zaoszczędzanie miejsca w programie w języku BASIC

1. Ponownie zakoduj program – jak wspomniano poprzednio, przebudowa programu uczyni go bardziej efektywnym. Zaoszczędzi również miejsce.
2. Usuń komentarze – komentarze są przechowywane jako dane ATASCII i jedynie zajmują miejsce w programie.
3. Zastąp stałą używaną trzy lub więcej razy zmienną. BASIC rezerwuje na każdą stałą siedem bajtów, natomiast na odwołanie do zmiennej tylko jeden bajt, zatem sześć bajtów zostaje zaoszczędzone przy każdym zastąpieniu stałej zmienną, której przypisano wartość tej stałej.
4. Inicjuj zmienne rozkazem READ – parametry rozkazu DATA są przechowywane jako kod ATASCII, po jednym bajcie na znak, natomiast polecenie przypisania wymaga siedmiu bajtów na jedną stałą.
5. Staraj się zastępować liczby używane wielokrotnie przez działania na zdefiniowanych wcześniej zmiennych – na przykład Z1 przypisano 1, Z2 przypisano 2, a jeśli jest potrzebne 3, to zamień je wyrażeniem Z1 + Z2.
6. Ustaw często używane numery wierszy (w GOSUB i GOTO) w predefiniowanych zmiennych – jeśli wiersz 100 jest wywoływany 50 razy, to można zaoszczędzić w przybliżeniu 300 bajtów przez przypisanie zmiennej Z100 wartości 100 i użycie jej w wywołaniach.
7. Utrzymuj minimalną liczbę zmiennych – każda nowa zmienna wymaga 8 bajtów więcej w tablicy wartości zmiennych plus kilka bajtów na jej nazwę.
8. Wyczyść tablicę wartości i nazw zmiennych – elementy zmiennych nie są usuwane z tablic wartości i nazw nawet po usunięciu z programu wszystkich odwołań do tych zmiennych. Aby je usunąć wylistuj program rozkazem LIST na dysk lub kasetę, wpisz NEW, a następnie wczytaj program rozkazem ENTER.
9. Utrzymuj nazwy zmiennych tak krótkie jak to możliwe – każda nazwa zmiennej jest umieszczana w tablicy nazw jako informacja ATASCII. Im krótsze są te nazwy, tym krótsza jest ta tablica.
10. Zamień powtarzający się tekst łańcuchem – na ekranach z dużą ilością tekstu można zaoszczędzić miejsce przez przypisanie łańcuchowi często używany zbiór znaków.
11. Inicjuj łańcuchy poleceniami przypisania – Przypisanie łańcucha z danymi w cudzysłowach wymaga mniej miejsca od rozkazu READ i funkcji CHR$.
12. Połącz wiersze w wielokrotne polecenia – trzy bajty można zaoszczędzić za każdym razem, gdy dwa wiersze zostaną zastąpione jednym wierszem z dwoma poleceniami.
13. Zastępuj jednokrotnie wywoływane podprogramy kodem bezpośrednim – rozkazy GOSUB i RETURN marnują bajty, jeśli są używane tylko jeden raz.
14. Zastępuj tablice liczbowe łańcuchami, jeśli wartości danych nie przekraczają 255 – elementy tablicy liczbowej wymagają sześć bajtów każdy, natomiast elementy łańcucha potrzebują tylko jednego.
15. Zastępuj polecenia SETCOLOR rozkazami POKE – zaoszczędzi to 8 bajtów.
16. Zamiast poleceń POSITION używaj znaków kontrolnych kursora. Polecenie POSITION wymaga 15 na parametry X,Y, natomiast znaki edycyjne kursora są pojedynczymi bajtami.
17. Usuwaj wierszy kodu poprzez program – zobacz do następnego podrozdziału.
18. Modyfikuj wskaźnik łańcucha/tablicy, aby załadować predefiniowane dane – przez zmianę wartości w STARP można zaoszczędzić informacji o łańcuchu i tablicy.
19. Małe procedury asemblerowe mogą być umieszczane w wywołaniach USR – na przykład X=USR(ADR("hhh*LVd"),16).
20. Łącz programy – przykładem może być procedura inicjalizacyjna, która zostaje uruchomiona najpierw, po czym ładuje ona program główny.

Przykład nr 1 – Inicjalizacja łańcucha – Ten program ustawi wszystkie bajty łańcucha dowolnej długości na tę samą wartość. BASIC kopiuje pierwszy bajt łańcucha źródłowego do pierwszego bajtu łańcucha docelowego itd. Przez ustawienie łańcucha docelowego jako łańcuch rozpoczynający się od drugiego bajtu łańcucha źródłowego ten sam znak zostanie umieszczony wzdłuż całego łańcucha.

10 REM INICJALIZACJA ŁAŃCUCHA
20 DIM A$(1000)
30 A$(1)="A":A$(1000)="A"
40 A$(2)=A$

Przykład nr 2 – Usuwanie wierszy kodu – Przez wykorzystanie pewnej cechy systemu operacyjnego program może usuwać lub modyfikować wiersze kodu wewnątrz siebie samego. Edytor ekranowy można ustawić na przyjmowanie danych z ekranu bez ich wprowadzania przez użytkownika. W ten sposób przez ustawienie najpierw ekranu, umieszczenie kursora na górze, a następnie zatrzymanie programu BASIC będzie otrzymywał rozkazy wydrukowane na ekranie.

10 REM PRZYKŁAD USUWANIA WIERSZY
20 GRAPHICS 0:POSITION 2,4
30 ? 70:? 80:? 90:? "CONT"
40 POSITION 2,0
50 POKE 842,13:STOP
60 POKE 842,12
70 REM TE WIERSZE
80 REM ZOSTANĄ
90 REM USUNIĘTE

Przykład nr 3 – Grafika graczy i pocisków w łańcuchach – W tym przykładzie pokazano pewien sposób szybkiego przenoszenia danych grafiki graczy i pocisków. Zwymiarowany łańcuch ma zmienioną wartość swojego offsetu obszaru łańcuchów/tablic, tak aby wskazywać na obszar grafiki P/M. Teraz zapis do tego łańcucha za pomocą polecenia przypisania zapisze te dane w obszarze P/M z szybkością języka asemblera.

100 REM PRZYKŁAD GRAFIKI GRACZY/POCISKÓW
110 DIM A$(512),B$(20)
120 X=X+1:READ A:IF A<>-1 THEN B$(X,X)=CHR$(A):GOTO 120
130 DATA 0,255,129,129,129,129,129,129,129,129,255,0,-1
2000 POKE 559,62:POKE 704,88
2020 I=PEEK(106)-16:POKE 54279,I
2030 POKE 53277,3:POKE 710,224
2040 VTAB=PEEK(134)+PEEK(135)*256
2050 ATAB=PEEK(140)+PEEK(141)*256
2060 OFFS=I*256+1024-ATAB
2070 HI=INT(OFFS/256):LO=OFFS-HI*256
2090 POKE VTAB+2,LO:POKE VTAB+3,HI
3000 Y=60:Z=100:V=1:H=1
4000 A$(Y,Y+11)=B$:POKE 53248,Z
4010 Y=Y+V:Z=Z+H
4020 IF Y>213 OR Y<33 THEN V=-V
4030 IF Z>206 OR Z<49 THEN H=-H
4420 GOTO 4000