creativ’08

Programmierwettbewerb zum 25. c't-Geburtstag

Wissen | Know-how

Als die erste c't erschien, standen in den Spielhallen Klassiker wie Space Invaders oder Asteroids. 25 Jahre später hat uns ein solcher Automat inspiriert, Sie herauszufordern: Schreiben Sie ein Programm, das Asteroids spielt!

Sie befinden sich in einem Ein-Mann-Raumschiff inmitten eines Asteroidenfelds. Mit Photonentorpedos können Sie Gesteinsbrocken abschießen, bevor es zu einer Kollision kommt. Doch Vorsicht: Große Brocken zerplatzen in kleinere, die aufgrund der Wucht der Explosion meist noch schneller fliegen. Und immer wieder tauchen UFOs mit aggressiven Aliens auf, die auf Sie schießen – wahrlich keine gemütliche Umgebung.

Mit Steuerdüsen lässt sich das Schiff nach links und rechts drehen und mit dem Haupttriebwerk beschleunigen. Zum Bremsen heißt es umdrehen und in die andere Richtung beschleunigen. Der Hyperraum-Antrieb ist leider kaputt: Man kann zwar einen Sprung wagen, weiß aber nicht, wo man wieder herauskommt und ob das Schiff die Belastung aushält. Also nur etwas für absolute Notfälle, wenn man dem sicheren Tod bereits ins Auge sieht.

Einen Schwarzweißbildschirm, einen 8-Bit-Prozessor mit 1,5 MHz, 8 KByte ROM und 3 KByte RAM brauchte Atari im Jahre 1979, um das packende Weltraum-Abenteuer namens Asteroids zu realisieren – wohlgemerkt Kilobyte, nicht Megabyte. Das Spiel war einer der größten Videospiel-Erfolge aller Zeiten und stand auch in Deutschland in den Spielhallen, als vor 25 Jahren die erste c't-Ausgabe erschien.

Wir haben es daher ausgewählt, um die nächste Runde unseres Jubiläumswettbewerbs creativ’08 zu eröffnen. Die Aufgabe: Schreiben Sie ein Programm, das Asteroids spielt. Es bekommt den Bildschirminhalt übermittelt und muss den Automaten über seine fünf Tasten Links, Rechts, Beschleunigen, Feuer und Hyperspace bedienen.

Da nicht jeder einen Asteroids-Automaten zu Hause stehen hat, werden wir den Wettbewerb mit einem Emulator austragen, dem als Open Source verfügbaren MAME (Multiple Arcade Machine Emulator). Wie der Name schon sagt, emuliert MAME Hunderte von Videospielen, darunter auch Asteroids. Wir haben den Emulator um eine Netzwerkschnittstelle erweitert: Per UDP nimmt er Tastendrücke entgegen und schickt auf demselben Wege Bildschirminhalte zurück.

Bevor es an die Details zum Wettbewerb geht, sei ein etwas ausführlicherer Blick auf die Technik von Asteroids gestattet. Wie haben die Entwickler es geschafft, mit nach heutigen Verhältnissen irrwitzig wenig Rechenleistung und Speicher ein so actiongeladenes Spiel zu realisieren?

Ein wesentlicher Trick, um eine hohe Auflösung bei minimalem Speicherbedarf zu erzielen, ist die Ansteuerung des Bildschirms als Vektordisplay. Bei einem klassischen Monitor tastet der Elektronenstrahl die Bildröhre Zeile für Zeile ab und wird in der Intensität moduliert, um das Bild zu erzeugen. Das Bild besteht also aus einer festen Zahl von Zeilen.

Heute, wo Speicher groß und billig ist, hat man einfach einen Bildschirmspeicher, der für jedes Pixel einen Farbwert speichert. Doch für einen Schwarzweißbildschirm mit Megapixel-Auflösung würde man mit dieser Technik selbst ohne Graustufen ein Megabit Speicher benötigen. 1979 war der letzte Schrei der Speichertechnik jedoch ein DRAM mit 16 KBit, das mehr als fünf Dollar kostete. Für ein Megabit hätte man 64 dieser Chips benötigt, der Bildschirmspeicher allein also mehrere hundert Dollar gekostet – und der arme kleine 6502-Prozessor mit seinem 16-Bit-Adressbus hätte so viel Speicher gar nicht ohne weiteres adressieren geschweige denn schnell genug diese Datenmengen bewegen können.

Der Trick beim Vektordisplay besteht darin, den Strahl direkt die gewünschten Objekte auf den Bildschirm zeichnen zu lassen. Der Bildschirmspeicher enthält nur noch eine Liste von zu zeichnenden Vektoren, und die ist vergleichsweise kurz. Um ein Megapixel Auflösung zu erreichen, steuert man die X- und Y-Ablenkung jeweils über einen 10-Bit-D/A-Wandler an; die Asteroids-Hardware erlaubt außerdem die Steuerung der Helligkeit in 16 Stufen (vier Bit).

Speichermäßig ist damit alles im Griff, doch wäre eine 6502-CPU hoffnungslos damit überfordert, in Echtzeitdie Vektorkoordinaten zu berechnen und an die D/A-Wandler zu verfüttern. Stattdessen entwickelte Atari-Ingenieur Howard Delman einen dedizierten Vektorgenerator, der eigenständig die Kommandos aus dem Bildschirmspeicher liest und den Strahl über die Mattscheibe führt.

Der Mikroprozessor kann sich somit ganz auf die Logik des Spiels konzentrieren. Dazu genügen ein 6 KByte großes Programm im ROM und 1 KByte RAM. Hinzu kommen 2 KByte Bildschirmspeicher, auf die CPU und Vektorgenerator beide Zugriff haben, sowie 2 KByte Vektor-ROM, dazu gleich mehr.

Auch mit der Sound-Erzeugung in Echtzeit wäre der 6502 überfordert. Deshalb übernehmen diskrete Tongeneratoren das Rumpeln, Krachen und Piepen. Sieben verschiedene Sound-Effekte gibt Asteroids von sich, und jeder ist als separate Schaltung realisiert, die auf Kommando genau ihren Ton von sich gibt. Die CPU braucht das Konzert über ein paar I/O-Ports nur zu dirigieren.

Nach heutigen Maßstäben erstaunlich wenig Speicher und Rechenleistung genügten den Atari-Ingenieuren für die Realisierung von Asteroids.

Mehr als die Hälfte aller Bauteile auf der Asteroids-Platine entfallen auf den Vektorgenerator. Er lässt sich am besten rückwärts beschreiben: Ganz hinten sitzt für X- und Y-Ablenkung jeweils ein 10-Bit-D/A-Wandler, der die Koordinate in ein Analogsignal umwandelt. Jede Koordinate steckt in einem Zähler, den man auf- oder abwärts zählen lässt, um den Strahl zu bewegen und einen Vektor zu zeichnen. Alternativ lassen sich programmgesteuert absolute Koordinaten in die Zähler laden. Der Strahl springt dann an eine neue Position.

Um Vektoren mit verschiedenen Winkeln zu zeichnen, muss der Strahl in X- und Y-Richtung unterschiedlich schnell bewegt, die Zähler für X und Y also mit verschiedenen Frequenzen getaktet werden. Das erledigen programmierbare Zähler, die eine vorgegebene Anzahl von Impulsen gleichmäßig verteilt über einen bestimmten Zeitraum abgeben. Der Kasten auf Seite 178 beschreibt den Vektorgenerator aus Software-Sicht und spricht von relativen Koordinaten und Skalierungsfaktoren, weil man sich als Programmierer das entstehende Bild so besser vorstellen kann. Durch die Hardware-Brille sieht man aber, dass es sich in Wirklichkeit um Geschwindigkeiten und Laufzeiten handelt.

Es ist nicht dasselbe, ob man einen Vektor mit hoher Geschwindigkeit in kurzer Zeit oder mit geringer Geschwindigkeit in längerer Zeit zeichnet. Denn die Helligkeit eines Vektors hängt vom Zeichentempo ab: Bewegt sich der Strahl schneller, so verteilt sich seine Energie auf eine längere Strecke und der Vektor wird dunkler. Damit alle Vektoren in etwa gleich hell erscheinen, programmiert die Asteroids-Software die Frequenzzähler in etwa derselben Größenordnung. Kürzere Vektoren werden durch kürzere Laufzeiten erzielt, im Kasten als Skalierungsfaktor beschrieben.

Für die Schüsse setzt Asteroids die Geschwindigkeit auf null und lässt den Strahl einfach eine Zeit lang auf der Stelle brennen. Auf der alten Schwarzweißröhre überstrahlen die Schüsse dann so richtig schön, ein Effekt, der wesentlich zum Charme des Spiels beiträgt – und dem Emulator leider völlig fehlt.

Das Herz des Vektorgenerators ist ein Zustandsautomat, bestehend aus einem kleinen PROM, dessen Ausgänge über ein Latch auf einen Teil der Eingänge zurückgekoppelt sind. Damit hat Delman praktisch einen Spezialprozessor konstruiert, der seine eigene kleine Maschinensprache versteht und der Reihe nach Instruktionen aus dem Vektorspeicher abarbeitet. Sogar Unterprogrammaufrufe beherrscht das Prozessörchen und hat zu diesem Zwecke einen kleinen Stack, der vier Rücksprungadressen fasst.

Und hier kommt das erwähnte Vektor-ROM zum Einsatz: Es enthält fertige Vektor-Unterprogramme für Asteroiden, Buchstaben, Ziffern und alle sonst im Spiel vorkommenden Formen. Wenn die Spielsoftware also einen Asteroiden zeichnen will, muss sie diesen nicht Vektor für Vektor in den Bildschirmspeicher schreiben, sondern stattdessen nur einen Unterprogrammaufruf. Über einen zuvor gesetzten globalen Skalierungsfaktor lässt sich die Größe der gezeichneten Figuren variieren. So genügt eine einzige Routine, um einen Asteroiden in groß, mittel oder klein zu zeichnen, und auch das UFO steht nur einmal im ROM, obwohl es im Spiel in zwei Größen auftritt.

Lediglich das eigene Raumschiff wird nicht als Subroutine aufgerufen, sondern als Einzelvektoren aus dem RAM gezeichnet. Der Grund ist wieder Speichergeiz: Im Vektor-ROM stehen Vorlagen für das Raumschiff in 16 verschiedenen Drehwinkeln von null bis 90 Grad. Um alle möglichen Winkel zu erhalten, kopiert die Software die Vorlagen ins RAM und spiegelt sie nach Bedarf an X- oder Y-Achse, indem sie Vorzeichenbits umkippt.

Der Inhalt des Vektorspeichers eignet sich ideal, um ihn per Software zu interpretieren und damit das Spielgeschehen zu analysieren. Die Spezialversion von MAME, die wir für unseren Programmierwettbewerb angefertigt haben, gibt einfach übers Netz den Inhalt des Vektor-RAM aus, genau genommen die Hälfte davon.

Asteroids arbeitet nämlich mit Double Buffering, einer Standardtechnik für flimmerfreie Animationen: Während der Vektorgenerator ein Bild zeichnet, errechnet der Mikroprozessor bereits das nächste. Dazu wird das Vektor-RAM zweigeteilt: In der einen Hälfte werkelt die CPU, die andere liest der Vektorgenerator aus. Da der Vektorgenerator immer bei Adresse 0 beginnt, schreibt die Software dort einen Sprungbefehl hin: entweder zur Adresse 1 oder nach $201 in die zweite Speicherhälfte. Das gepatchte MAME schnürt einfach das jeweils benötigte Kilobyte des RAM zu einem UDP-Paket.

Das Netzwerkprotokoll UDP haben wir deswegen gewählt, weil es ohne Flusskontrolle arbeitet. Es ist MAME also egal, ob der Empfänger die Daten schnell genug verarbeiten kann und ob überhaupt einer zuhört, er schickt einfach Frame für Frame ungebremst auf die Reise. Umgekehrt nimmt MAME per UDP – standesgemäß auf Port 1979 – Tastendrücke für die Steuerung entgegen, sodass man ihn übers Netz spielen kann. Natürlich dürfen Emulator und das spielende Programm auch auf ein und demselben Rechner laufen.

Wir stellen über den Soft-Link die Spezialversion von MAME für Windows, Linux und Mac OS zum Download bereit, der Open-Source-Lizenz folgend natürlich mit Quelltext. Nicht Bestandteil von MAME ist die Asteroids-Software, die im Originalautomaten in ROMs gespeichert ist. Die ROM-Images sind urheberrechtlich geschützt und dürfen nicht ohne weiteres im Internet verbreitet werden. Die Firma Atari hat uns aber freundlicherweise die Erlaubnis erteilt, die Asteroids-ROMs den Teilnehmern unseres Wettbewerbs zur Verfügung zu stellen. Wenn Sie mitmachen wollen, schreiben Sie bitte eine E-Mail an asteroids@ctmagazin.de. Wir senden Ihnen dann die magischen acht Kilobyte zu.

Zum Download finden Sie außerdem eine minimale Lösung für die Aufgabe dieses Wettbewerbs: ein Programm, das übers Netzwerk Asteroids spielt. Der Beispielcode in C++ zeigt insbesondere, wie man die Daten des Vektorspeichers interpretiert und daraus die Koordinaten von Raumschiff, Asteroiden, Schüssen und UFOs extrahiert. Er ballert was das Zeug hält und dreht das Raumschiff immer in Richtung des nächstgelegenen Objekts; Schub und Hyperspace lässt er links liegen. Mit dieser Primitivstrategie ist natürlich kein Blumentopf zu gewinnen, aber mit Glück kommt sie gelegentlich sogar über 10 000 Punkte. Sie können den Code nach Belieben verwenden, gerne aber auch alles komplett selbst programmieren.

Bezüglich der Programmiersprache und -umgebung haben Sie die freie Auswahl. Wir werden den Wettbewerb auf aktueller Hardware (Dual-Core-Prozessor, 2 GByte RAM) austragen und dabei den Emulator auf einer separaten Maschine laufen lassen, um Beeinflussungen durch die teilnehmenden Programme auszuschließen. Ihr Programm muss unter Windows XP Professional, Ubuntu Linux 7.10 oder Mac OS X 10.5 funktionieren und in lauffähiger Form sowie im Quelltext bereitgestellt werden. Für eine aktuelle Java-Runtime und ein .NET-Framework sorgen wir; andere eventuell benötigte Laufzeitumgebungen müssen Sie mitliefern.

Es gewinnt das Programm mit der höchsten Punktzahl. Da bei Asteroids auch der Zufall mitspielt, werden wir jedes Programm mehrmals antreten lassen und unter den Favoriten dann einen Wettkampf im K.-o.-System austragen. Anders als in der Spielhalle gilt bei uns zusätzlich ein Zeitlimit von voraussichtlich zehn Minuten. Sollten also mehrere Teilnehmer „perfekt“ spielende Programme hinbekommen, so gewinnt dasjenige, das am schnellsten abräumt. Auf der Webseite zu diesem Wettbewerb, die Sie über den Soft-Link erreichen, haben wir ein Diskussionsforum eingerichtet, wo sich die Teilnehmer über Erfahrungen und Probleme austauschen können. Dort werden wir falls nötig auch Updates oder weitere Dokumentation veröffentlichen.

Die drei besten Programme prämieren wir mit Preisen im Gesamtwert von 6000 Euro. Hauptgewinn ist ein Full-HD-Beamer, der Panasonic PT-AE2000, dazu eine Playstation 3 (wahlweise 3000 Euro in bar). Der Zweitplatzierte erhält den 30-Zoll-Monitor UltraSharp 3008WFP von Dell und eine dazu passende Dual-Link-fähige Grafikkarte oder 2000 Euro in bar. Den dritten Platz honorieren wir mit dem Multimedia-Notebook Acer Aspire 8920G mit Full-HD-Display und Blu-ray-Laufwerk oder 1000 Euro. Die Teilnehmer auf den Plätzen 4 bis 25 erhalten jeweils ein c't-Jahresabo. Schließlich losen wir unter allen Teilnehmern der creativ’08-Wettbewerbe insgesamt 200 aus und laden sie zu unserer Jubiläumsparty im Herbst in Hannover ein.

Schicken Sie Ihre Programme per E-Mail asteroids@ctmagazin.de an. Einsendeschluss ist der 30. Juni 2008. Mitarbeiter der Heise Medien Gruppe sind nicht teilnahmeberechtigt. Der Rechtsweg ist ausgeschlossen. (bo)

Soft-Link

Der Vektorgenerator adressiert Vektor-RAM und -ROM als 16-Bit-Wörter. In seinem Adressraum liegen die 2 KByte RAM an den Adressen 0 bis $3FF, die 2 KByte ROM an $800 bis $BFF. Der Befehlssatz umfasst 16 Opcodes, wobei die Codes 0 bis $A Zwei-Wort-Befehle sind, der Rest Ein-Wort-Befehle. Wenn der 6502 ein Bild fertig berechnet hat, gibt er den Startschuss und der Vektorgenerator beginnt ab Adresse 0 seine Instruktionen abzuarbeiten.

0 … 9: VCTR – langer Vektor

Diese Familie von Befehlen mit den Opcodes OP von 0 bis 9 zeichnet einen Vektor mit Helligkeit Z (0 = unsichtbar, …, 15 = ganz hell) in Richtung (X, Y), wobei X und Y relativ zur aktuellen Strahlposition zu verstehen sind. Die Vorzeichenbits XS und YS geben die Richtung an (0 = positiv = rechts bzw. oben). X und Y werden durch einen Skalierungsfaktor dividiert, der sich als Summe aus dem Opcode und dem globalen Skalierungsfaktor GSF ergibt (siehe LABS).

OP + GSF Divisor
9 1
8 2
7 4
6 8
. .
. .
. .
0 512

Steht der globale Skalierungsfaktor auf null, so zeichnet der Opcode 6 also beispielsweise einen Vektor mit einem Achtel der in (X, Y) angegebenen Länge.

$A: LABS – Strahl positionieren


Setzt den Strahl auf die absolute Position (X, Y) und speichert den globalen Skalierungsfaktor GSF. Er gilt bis zum nächsten LABS-Befehl für alle Vektor-Operationen und wird ohne Berücksichtigung des Überlaufs als 4-Bit-Wert auf die bei VCTR und SVEC angegebenen Skalierungsfaktoren addiert: Der Wert 15 ist also effektiv eine –1, 14 entspricht –2 und so weiter.

$B: HALT – Programmende

$C: JSRL – Subroutine aufrufen

Schiebt die Adresse des nächsten Befehls auf den Stack und springt die absolute Adresse A an.

$D: RTSL – Rückkehr Subroutine

Holt eine Rücksprungadresse vom Stack und setzt die Ausführung dort fort.

$E: JMPL – Unbedingter Sprung

Springt an die angegebene absolute Adresse A wie bei JSRL, jedoch ohne die Rücksprungadresse auf dem Stack zu sichern.

$F: SVEC – kurzer Vektor


Zeichnet einen Vektor mit Helligkeit Z in Richtung (X, Y) mit Vorzeichen XS und YS. Nur die beiden höchstwertigen Bits der 10-Bit-Werte X und Y sind angegeben; der Rest wird mit Nullen aufgefüllt. Wie bei VCTR wird der globale Skalierungsfaktor in Summe mit SF angewandt:

SF + GSF Divisor
3 16
2 32
1 64
0 128
Adressen im Vektor-ROM
Adresse Funktion Adresse Funktion
852 Copyright-Meldung ADD Buchstabe O/Ziffer 0
880 Explosion groß (3)
896 Explosion (2) B26 Buchstabe Z
8B5 Explosion (1) B2C Leerzeichen
8D0 Explosion klein (0) B2E 1
8F3 Asteroid Typ 1 B32 2
8FF Asteroid Typ 2 B3A 3
90D Asteroid Typ 3 B41 4
91A Asteroid Typ 4 B48 5
929 UFO B4F 6
A6D Raumschiff aufrecht B56 7
A78 Buchstabe A B5B 8
B63 9
In dieser Visualisierung eines Bildschirminhalts zeigen rote Linien Vektoren an, die normalerweise unsichtbar sind.

So sieht der abgebildete Bildschirminhalt in der Sprache des Vektorgenerators aus.

000 E001       JMPL $001
001 A11C 0311 LABS (785, 284), s0
003 7000 0000 VCTR (0, 0), s7, z0 ; Ruhezeit
005 7000 F000 VCTR (0, 0), s7, z15 ; Schuss
007 A167 E2BC LABS (700, 359), s14
009 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
00B 7000 F000 VCTR (0, 0), s7, z15 ; Schuss
00D A19D F281 LABS (641, 413), s15
00F 8000 0000 VCTR (0, 0), s8, z0 ; Ruhezeit
011 7000 F000 VCTR (0, 0), s7, z15 ; Schuss
013 A27B E23C LABS (572, 635), s14
015 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
017 7000 F000 VCTR (0, 0), s7, z15 ; Schuss
019 A2C4 F126 LABS (294, 708), s15
01B 8000 0000 VCTR (0, 0), s8, z0 ; Ruhezeit
01D C929 JRSL $929 ; UFO
01E A1AB E272 LABS (626, 427), s14
020 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
022 4380 0500 VCTR (-256, 896), s4, z0
024 4720 C680 VCTR (-640, -800), s4, z12 ; Schiff
026 4440 C6E0 VCTR (-736, -64), s4, z12
028 6520 C2F8 VCTR (760, -288), s6, z12
02A 62B0 C5B0 VCTR (-432, 688), s6, z12
02C 46E0 C040 VCTR (64, -736), s4, z12
02E A0A8 E232 LABS (562, 168), s14 ; Skalierung -2 (klein)
030 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
032 C8F3 JRSL $8F3 ; Asteroid (Typ 1)
033 A315 0108 LABS (264, 789), s0 ; Skalierung 0 (groß)
035 7000 0000 VCTR (0, 0), s7, z0 ; Ruhezeit
037 C91A JRSL $91A ; Asteroid (Typ 4)
038 A316 E13F LABS (319, 790), s14 ; Skalierung -2 (klein)
03A 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
03C C8FF JRSL $8FF ; Asteroid (Typ 2)
03D A1DA E011 LABS (17, 474), s14 ; Skalierung -2 (klein)
03F 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
041 C8F3 JRSL $8F3 ; Asteroid (Typ 1)
042 A21A F333 LABS (819, 538), s15 ; Skalierung -1 (mittel)
044 8000 0000 VCTR (0, 0), s8, z0 ; Ruhezeit
046 C91A JRSL $91A ; Asteroid (Typ 4)
047 A1CF E1DD LABS (477, 463), s14 ; Skalierung -2 (klein)
049 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
04B C8F3 JRSL $8F3 ; Asteroid (Typ 1)
04C A283 E19D LABS (413, 643), s14 ; Skalierung -2 (klein)
04E 9000 0000 VCTR (0, 0), s9, z0 ; Ruhezeit
050 C91A JRSL $91A ; Asteroid (Typ 4)
051 A127 F132 LABS (306, 295), s15 ; Skalierung -1 (mittel)
053 8000 0000 VCTR (0, 0), s8, z0 ; Ruhezeit
055 C8FF JRSL $8FF ; Asteroid (Typ 2)
056 A2EC F25D LABS (605, 748), s15 ; Skalierung -1 (mittel)
058 8000 0000 VCTR (0, 0), s8, z0 ; Ruhezeit
05A C8FF JRSL $8FF ; Asteroid (Typ 2)
05B C852 JRSL $852 ; Copyright-Meldung
05C A36C 1064 LABS (100, 876), s1
05E 7000 0000 VCTR (0, 0), s7, z0 ; Ruhezeit
060 CB2C JRSL $B2C ; Leerzeichen
061 CB2C JRSL $B2C ; Leerzeichen
062 CB3A JRSL $B3A ; 3
063 CB2E JRSL $B2E ; 1
064 CADD JRSL $ADD ; 0
065 A354 E0A0 LABS (160, 852), s14
067 CA6D JRSL $A6D ; Schiff
068 CA6D JRSL $A6D ; Schiff
069 CA6D JRSL $A6D ; Schiff
06A A36C 01E0 LABS (480, 876), s0
06C 5000 0000 VCTR (0, 0), s5, z0 ; Ruhezeit
06E CB2C JRSL $B2C ; Leerzeichen
06F CB2C JRSL $B2C ; Leerzeichen
070 CB2C JRSL $B2C ; Leerzeichen
071 CADD JRSL $ADD ; 0
072 CADD JRSL $ADD ; 0
073 A36C 1300 LABS (768, 876), s1
075 5000 0000 VCTR (0, 0), s5, z0 ; Ruhezeit
077 A1FC 11FC LABS (508, 508), s1
079 B0B0 HALT

Kommentare

Kommentare lesen (2188 Beiträge)

Anzeige
Anzeige