BASIC V2 Interpreter/Compiler in/für Java

  • Was mir durch flüchtige Blicke auf VMs usw., auch durch den anderen Basic-Thread, aufgefallen ist: Stack-Maschinen sind da unheimlich beliebt. Paar Kommandos, um Werte auf "einen" Stack zu legen oder runter zu holen, aber die Hauptarbeit wird von Kommandos mit Bezug auf die letzten Stackeinträge erledigt.
    Aber warum? Sind es nur die Einfachheit der Befehle und die einfache Übergabe von Parametern? Eventuelle Vorteile beim echten Compilieren werden vermutlich kein Grund sein, all die VMs sind ja quasi als Interpreter losgelaufen.

    Sind Stackmaschinen auch in Hardware verbreitet? Ich kenne jetzt nur die alten Prozessoren, die alles im Speicher gemacht haben, und die Microprozessoren, die Register mögen.

    M. J. schrieb:

    Was den Stack anbelangt, so gibt es drei Möglichkeiten, diesen auf dem C64 zu gestalten:
    1.) Du definierst eine maximale Tiefe von 8-12, was meiner Erfahrung nach für die meisten Berechnungen ausreicht. Dafür legst Du im Speicher 6 kleine Tabellen an,
    Den Teil hab ich jetzt nicht verstanden. Woher die 6? 6 Stacks für verschiedene Zwecke wie Gosub/Return, For/Next, Formeln berechnen u.Ä.? Oder weil der komplizierteste Datentyp auf dem Stack 6 Bytes belegen kann?
    Vollmond war gestern!
  • Hoogo schrieb:

    Aber warum? Sind es nur die Einfachheit der Befehle und die einfache Übergabe von Parametern?
    Es ist ein recht einfach zu verstehendes Konzept und im Gegensatz zu registerbasierten Maschinen kann man sich die die Implementierung einer Registerallokation sparen.

    Eventuelle Vorteile beim echten Compilieren werden vermutlich kein Grund sein, all die VMs sind ja quasi als Interpreter losgelaufen.
    Java verwendet zB ebenfalls eine Registermaschine als Bytecode.

    Sind Stackmaschinen auch in Hardware verbreitet?
    Kaum. Der Nachteil von Stackmaschinen in echter Hardware ist, dass sie ziemlich viele Speicherzugriffe erzeugen, auch wenn man das etwas abfangen kann, indem die obersten Stackeinträge in der CPU statt in externem Speicher abgelegt werden. Jenseits einiger Forth- und Java-Obskuritäten fällt mir spontan eigentlich nur die ZPU ein, das ist ein für minimalen FPGA-Platzbedarf optimierter Prozessor mit reiner Stack-Architektur. Glücklicherweise gibt es einen gcc dafür, direkt in dessen Assemblercode zu programmieren fühlt sich doch reichlich ungewohnt an.

    Quellcode

    1. 10 x=rnd(-1963):fori=1to81:y=rnd(1):next
    2. 20 forj=1to5:printchr$(rnd(1)*16+70);:next
    3. 30 printint(rnd(1)*328)-217

    sd2iec Homepage
  • Unseen schrieb:

    Java verwendet zB ebenfalls eine Registermaschine als Bytecode.

    Grad Java sieht für mich sehr nach Stack aus (link), LLVM nach irgendwas mit unendlichen Registern (link). Aber ich hab das auch nur sehr oberflächlich betrachtet.

    Unseen schrieb:

    Der Nachteil von Stackmaschinen in echter Hardware ist, dass sie ziemlich viele Speicherzugriffe erzeugen, auch wenn man das etwas abfangen kann, indem die obersten Stackeinträge in der CPU statt in externem Speicher abgelegt werden. Jenseits einiger Forth- und Java-Obskuritäten fällt mir spontan eigentlich nur die ZPU ein, das ist ein für minimalen FPGA-Platzbedarf optimierter Prozessor mit reiner Stack-Architektur. Glücklicherweise gibt es einen gcc dafür, direkt in dessen Assemblercode zu programmieren fühlt sich doch reichlich ungewohnt an.
    Ist ja irgendwie komisch. Auch Register sind irgendwann mal aufgebraucht und müssen gerettet werden, und dann kommen die Speicherzugriffe doch, am besten noch über den Umweg eines Stacks... Da scheint mir ein Stack geeigneter, solche Zugriffe zu bündeln und vielleicht die nötigen Speicherzugriffe versteckt zu erledigen.
    Vollmond war gestern!
  • Hoogo schrieb:

    Unseen schrieb:

    Java verwendet zB ebenfalls eine Registermaschine als Bytecode.
    Grad Java sieht für mich sehr nach Stack aus (link)
    Stimmt, da stand ursprünglich "eine Stack- statt Registermaschine" und das wurde dann falsch zusammengestrichen.

    LLVM nach irgendwas mit unendlichen Registern (link). Aber ich hab das auch nur sehr oberflächlich betrachtet.
    Könnte man so nennen, allerdings kann jedes dieser "Register" nur einmal beschrieben werden und ändert sich dann nie wieder.

    Ist ja irgendwie komisch. Auch Register sind irgendwann mal aufgebraucht und müssen gerettet werden, und dann kommen die Speicherzugriffe doch, am besten noch über den Umweg eines Stacks... Da scheint mir ein Stack geeigneter, solche Zugriffe zu bündeln und vielleicht die nötigen Speicherzugriffe versteckt zu erledigen.
    Manchmal werden Register auch als "Level 0-Cache"(*) bezeichnet - es sind die schnellsten Speicher, die im Prozessor verfügbar sind. Natürlich muss man irgendwann deren Inhalt retten, aber je länger man es herauszögern kann, um so weniger fallen die Kosten dafür im Mittel an.

    (*) Disclaimer: Es gibt inzwischen einige Nicht-Register-Konzepte, die den Namen eher verdient haben, zB Microop-Caches

    Quellcode

    1. 10 x=rnd(-1963):fori=1to81:y=rnd(1):next
    2. 20 forj=1to5:printchr$(rnd(1)*16+70);:next
    3. 30 printint(rnd(1)*328)-217

    sd2iec Homepage
  • Hoogo schrieb:

    Den Teil hab ich jetzt nicht verstanden. Woher die 6? 6 Stacks für verschiedene Zwecke wie Gosub/Return, For/Next, Formeln berechnen u.Ä.? Oder weil der komplizierteste Datentyp auf dem Stack 6 Bytes belegen kann?
    Letzteres. Fließkommazahlen brauchen (entpackt) 6 Bytes. Anstelle diese 6 Bytes nacheinander auf den Stack zu legen

    Quellcode

    1. lda facc
    2. sta stack, x
    3. inx
    4. lda facc + 1
    5. sta stack, x
    6. inx
    7. ...
    8. lda facc + 5
    9. sta stack, x
    10. inx
    splittet man den Stack in 6 Teile, was auch gleich die maximale Anzahl an Einträgen erhöht.

    Quellcode

    1. lda facc
    2. sta stack_0, x
    3. lda facc + 1
    4. sta stack_1, x
    5. ...
    6. lda facc + 5
    7. sta stack_5, x
    8. inx

    Unseen schrieb:

    Der Nachteil von Stackmaschinen in echter Hardware ist, dass sie ziemlich viele Speicherzugriffe erzeugen, auch wenn man das etwas abfangen kann, indem die obersten Stackeinträge in der CPU statt in externem Speicher abgelegt werden.
    Man muß dabei unterscheiden zwischen Stackmaschinen mit nur einem Stack für Variablen, Returnadresse und Termberechnung und solchen mit zwei Stapeln: einen für Variablen und Returnadresse und einen Evaluationsstack für die Termberechnung. Letzterer braucht, wie beschrieben, bloß aus ein paar Einträgen zu bestehen, nicht mehr als ein Registersatz eines Prozessors. Dadurch werden alle Rechenoperationen wie bei einem Prozessor im "Level 0-Cache" ausgeführt. Das reduziert die Speicherzugriffe und die Cachebelegung (Level 1..) deutlich, was die Unterschiede zwischen einer Stackmaschine und einer Registermaschine mindert.

    Hoogo schrieb:

    nur die Einfachheit der Befehle
    Gerade auf dem C64 (bzw. auf dem 6502) ergeben sich dadurch, daß Stackmaschinen über einfache Befehle verfügen, mehrere Vorteile.
    1.) Die Befehle sind deutlich kürzer, da keine Angaben gemacht werden müssen, welche Register bei der Operation zur Anwendung kommen sollen. Dadurch werden nicht nur die Programme kürzer (Stackmaschinencode ist sehr kompakt und eignet sich daher besonders gut für kleinen Speicher), auch die Ausführungszeit wird schneller als bei der Emulation einer Registermaschine, da die Befehlsdekodierung einfacher ist.
    2.) Einfache Befehle bedeuten auch, daß der Interpreter relativ kurz ist, was wiederum Platz im Rechner spart.

    Hoogo schrieb:

    Eventuelle Vorteile beim echten Compilieren werden vermutlich kein Grund sein
    Oh doch. Wie Unseen schon schrieb, ist die Registerallokation sehr aufwendig. Hinzukommen auch die ganzen Komplikationen bei nicht-orthogonalen Befehlssätzen (wie beim x86: Integer-Multiplikation nur über EAX...). Außerdem können komplizierte Vorgänge sehr leicht in einem Befehl gebündelt werden, z. B. eine Stringaddition durchführen oder Speicher kopieren. Kurz: Es ist wesentlich leichter, ein Backend zu schreiben für eine Stackmaschine als für eine Registermaschine.

    Nachtrag:
    Gerade bei der Kompilierung vom ansonsten interpretierten BASIC-Code, bei dem die Bedeutung des NEXT (oder auch RETURN) laufzeitabhängig ist, wäre es sinnvoll, eine Stackmaschine zu verwenden mit einem Sonderbefehl "Next-Ausführen". Ebenso kann man eigene Befehle einbauen für PRINT, READ und anderen Standardbefehlen. Der Unterschied zwischen dem BASIC-Tokencode und dem Stackmaschinencode ist dann nicht mehr so groß.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von M. J. ()

  • M. J. schrieb:

    Hoogo schrieb:

    Eventuelle Vorteile beim echten Compilieren werden vermutlich kein Grund sein
    Oh doch. Wie Unseen schon schrieb, ist die Registerallokation sehr aufwendig. Hinzukommen auch die ganzen Komplikationen bei nicht-orthogonalen Befehlssätzen (wie beim x86: Integer-Multiplikation nur über EAX...). Außerdem können komplizierte Vorgänge sehr leicht in einem Befehl gebündelt werden, z. B. eine Stringaddition durchführen oder Speicher kopieren. Kurz: Es ist wesentlich leichter, ein Backend zu schreiben für eine Stackmaschine als für eine Registermaschine.
    Ja, wenn man es bei einem Interpreter für die VM lasen will, dann sehe ich das auch schnell ein. Aber wenn das Ergebnis ein richtiges Kompilat sein soll, dann war der Code für die VM nur ein Zwischenschritt, und dann kommen halt zu dieser späten Stelle die alten Probleme wieder hoch. Ich glaub nicht so recht, dass man beim Design der JVM schon einen späteren JIT-Compiler im Auge hatte.

    EgonOlsen71 schrieb:

    Vielleicht eine kleine Anmerkung, was Java und Stackmachines angeht: Das stimmt für die Desktop-VMs, aber z.B. nicht für Dalvik/ART auf Android. Die nehmen wiederum den stackbasierten Bytecode und konvertieren ihn in etwas registerbasiertes, um dann darauf zu arbeiten.
    Darüber hab ich interessanten Lesestoff gefunden: Stack vs. Register
    Comparison of VMs
    Vollmond war gestern!
  • Hoogo schrieb:

    Darüber hab ich interessanten Lesestoff gefunden: Stack vs. RegisterComparison of VMs
    Wobei der Performancevergleich hier nicht eine stackbasierte VM mit einer registerbasierten VM des gleichen Kalibers vergleicht und von daher meiner Ansicht nach fast keine Aussagekraft bzgl. Stack vs. Register hat.
    Der JIT bei Dalvik war nie besonders gut, er war ursprünglich auch überhaupt nicht angedacht. Die ersten Aussagen über Dalvik gingen in die Richtung: "JIT? Brauchen wir nicht, machen wir nicht!"
    Mit ART haben sie dann erst komplett auf AOT-Kompilierung umgeschwenkt, um jetzt in der letzten Fassung einen Mix aus allen drei Optionen (Interpreter, JIT und AOT (in zwei Ausprägungen, einmal "schnell" und einmal "gut")) zu bieten. Von daher ist die aktuelle Android-VM am ehesten mit Hotspot vergleichbar...aber da kenne ich leider keine vergleichenden Tests.
  • Update: Ein weiterer kleiner Meilenstein ist erreicht. Das Teil kann jetzt mein gerne als Testfall benutztes Programm Lyric 3.0 (aus einer alten 64er, meine ich) in lauffähigen Pseudo-Assembler-Code compilieren (bis auf OPEN, CLOSE und PRINT#...das unterstütze ich bisher aus Faulheit noch nicht).

    BASIC-Version:

    Quellcode

    1. 1 rem lyric 3.0
    2. 2 rem ---------
    3. 3 rem it's an experience !
    4. 4 rem
    5. 5 rem written by
    6. 6 rem dirk meier
    7. 7 rem brendel 30
    8. 8 rem 4980 buende 12
    9. 9 rem tel. 05223/42823
    10. 10 rem
    11. 11 rem anzahl von:
    12. 12 q0=19:rem mnemonic-ketten
    13. 13 q1=8:rem praepositionen
    14. 14 q2=6:rem temporale bestimmungen
    15. 15 q3=25:rem konjunktionen
    16. 16 q4=138:rem nomen,adjektive
    17. 17 q5=90:rem verben
    18. 18 q6=10:rem irgendwelche worte
    19. 19 q7=8:rem endsilben fuer nomen
    20. 20 q8=6:rem irgendwelche subjekte
    21. 21 poke53281,14:poke53280,6:printchr$(147)chr$(14)chr$(8)
    22. 22 dimva%(20),mn$(150),pm$(20,1),d2$(11),d3$(15),d4$(15),d%(138+90-2)
    23. 24 dimen$(15),ar$(15),pr$(8-1),ze$(6-1),ko$(25-1),no$(138-1,3)
    24. 26 dimvb$(90-1,2),e$(20),co$(19-1),iw$(10-1),ks$(6-1)
    25. 28 s1=54272:s2=s1+7:s3=s2+7:fora=0to24:pokes1+a,0:next
    26. 29 fora=1to20:forb=1to0step-1:print"";:poke646,b:pokes1+24,0:pokes1+24,15
    27. 30 print:print" Dirk Meier's Lyric 3.0":print" ======================":nextb,a
    28. 31 poke646,1:print:print" Ein Gedicht-Synthese Programm."
    29. 32 print:print" Entwickelt nach naechtelangen"
    30. 34 print" Schlachten mit der deutschen Grammatik."
    31. 36 print" Greetings to Storm,Borchert,Fried,Astel und Enzensberger..."
    32. 38 print:print" But never forget:":print" Keep it heavy and keep it hard..."
    33. 40 print:print" Aber jetzt: NIL NISI OPTIMUS !":print
    34. 44 printchr$(18)" Ich warte auf eine Reaktion von Ihnen "
    35. 46 geta$:ifa$=""then46
    36. 47 gosub970:printchr$(18)" Bitte etwas warten "
    37. 49 fora=1to35:reada$:next
    38. 50 fora=0toq0-1:readco$(a),a$:next:reada$,a$,a$
    39. 52 fora=0to15:readen$(a):next:rem endungen
    40. 53 fora=0to11:readd2$(a):next:rem endungen2
    41. 54 fora=0to15:readd3$(a):next:rem endungen3
    42. 55 fora=0to15:readd4$(a):next:rem endungen4
    43. 56 fora=0to15:readar$(a):next:rem best.artikel
    44. 58 fora=0toq1-1:readpr$(a):next:rem praepositionen
    45. 59 forb=0toq2-1:readze$(b):nextb:rem temp. bestimmungen
    46. 60 fora=0toq3-1:readko$(a):next:rem konjunktionen
    47. 61 fora=0toq6-1:readiw$(a):next:rem irgendwelche worte
    48. 62 fora=0toq8-1:readks$(a):nexta:rem irg. subst.
    49. 63 fora=0toq4-1:forb=0to3:readno$(a,b):nextb,a:rem nomen,adjektive
    50. 64 fora=0toq5-1:forb=0to2:readvb$(a,b):nextb,a:rem verben
    51. 100 gosub970:printchr$(147)" Ausdrucken lassen wollen Sie Sich die"
    52. 102 print" Gedichte doch sicherlich...oder ?":gosub980
    53. 105 getdr$:ifdr$<>"j"anddr$<>"n"then105
    54. 107 a$=dr$:gosub900:goto800
    55. 108 print:print" Kommen wir zu dem Aufbau der Strophen."
    56. 109 print" Wie viele Strophen sollen es sein ?";:gosub980
    57. 110 gosub920:az=kk:ifaz=1then122
    58. 111 ifaz<1thenprint:goto110
    59. 112 print:print" Sollen alle "az" Strophen die gleiche"
    60. 113 print" Anzahl von Versen haben ?";:gosub980
    61. 114 getf3$:iff3$="j"thenprint" ja":goto122
    62. 116 iff3$<>"n"then114
    63. 118 print" nein":print" Wieviel Verse sollen es jeweils sein ?":ford=0toaz-1
    64. 120 printd+1". Strophe ";:gosub920:va%(d)=kk:next:goto136
    65. 122 print:print" Vieviele Verse sollen es sein ?";:gosub980:gosub920:f1=kk
    66. 124 fora=0toaz-1:va%(a)=f1:next
    67. 134 a$=ch$:gosub900:print
    68. 136 print" Wir kommen zum formalen Aufbau der":print" Strophen und Verse."
    69. 138 print" Wollen Sie eigene Satzstrukturen"
    70. 140 print" eingeben (1) oder bereits gespeicherte":print" verwenden (2)";
    71. 141 gosub980
    72. 142 getf1$:iff1$<>"1"andf1$<>"2"then142
    73. 144 iff1$="2"thenprint" gespeicherte":goto200
    74. 146 print" selbst eingeben"
    75. 180 printchr$(147):print" 1. Strophe":fora=1tova%(0):printa". Vers";
    76. 181 inputmn$(a-1):next:iff3$="n"thenprint:goto190
    77. 182 ifaz=1then196
    78. 183 print:print" Sollen alle restlichen Strophen den"
    79. 184 print" gleichen Aufbau besitzen ";:gosub980
    80. 185 getf1$:iff1$="j"thenprint" ja":goto196
    81. 186 iff1$<>"n"then185
    82. 190 print" nein":fora=1toaz-1:printa+1". Strophe":forb=1tova%(a):printb". Vers";
    83. 192 input" ";mn$(a*va%(a)+b-1):nextb:print:nexta:goto300
    84. 196 fora=1toaz:forb=0tova%(0)-1:mn$(a*va%(a)+b)=mn$(b):nextb,a:goto300
    85. 200 print:print" Ihr C64 wird Ihnen nun alle in den"
    86. 202 print" DATA-Zeilen gespeicherten Satz-"
    87. 204 print" strukturen auflisten und fragen,"
    88. 206 print" ob Sie sie bei 'Ihrem' Gedicht "
    89. 208 print" vielleicht brauchen koennen.":print" Eine erste Auswahl also."
    90. 210 print" Damit Sie sehen,was sie da so aus-"
    91. 212 print" waehlen,wird Ihnen zu jeder Struktur"
    92. 214 print" ein Satz geliefert,wie er vom Proramm"
    93. 216 print" unter Benutzung eben jener Struktur"
    94. 218 print" produziert werden koennte.":zz=0:restore:gosub980
    95. 219 fora=1to35:reada$:next
    96. 220 print:reada$,b$:ifa$="@@@"then230
    97. 221 printa$:printb$:printchr$(18)"j/n"
    98. 222 getc$:ifc$="n"then220
    99. 224 ifc$<>"j"then222
    100. 226 pm$(zz,0)=a$:pm$(zz,1)=b$:zz=zz+1:printpm$(zz,1),zz:goto220
    101. 230 print:print" Waehlen Sie nun fuer jeden Vers die"
    102. 232 print" gewuenschte Satzstruktur aus.":gosub980
    103. 234 geta$:ifa$=""then234
    104. 236 printchr$(147):print:fora=0tozz-1:printchr$(a+65)". ";pm$(a,1):next
    105. 238 fora=0toaz-1:forb=0tova%(a)-1:printchr$(19)" "
    106. 239 printchr$(19)a+1". Strophe,"b+1". Vers "
    107. 240 geta$:ifa$=""then240
    108. 241 ifasc(a$)<65orasc(a$)>zz+64then240
    109. 242 mn$(a*va%(a)+b)=pm$(asc(a$)-65,0):nextb,a
    110. 300 rem +++++ mnemonics auswerten ++++
    111. 301 poke53281,5:poke53280,0:poke646,1:printchr$(147);
    112. 302 fora=1to10:print:next:printtab(10);
    113. 303 fora=1to19:printmid$("l'art pour l'art...",a,1);:forb=1to10
    114. 304 pokes1+24,0:pokes1+24,15:nextb,a:fora=1to1000:next:ifdr$="j"thenopen1,4,0
    115. 305 printchr$(147):fora=0toaz-1:forb=0tova%(a)-1:w$=mn$(a*va%(a)+b):z1=1:z2=0
    116. 306 m$=mid$(w$,z1,3):ifm$=""then712
    117. 307 rem ---- und ----
    118. 308 ifm$="und"thene$(z2)=m$:z1=z1+4:goto710
    119. 309 rem ---- oder ----
    120. 310 ifm$="odr"thene$(z2)="oder":z1=z1+4:goto710
    121. 311 rem ---- praeposition ----
    122. 312 ifm$="pra"thene$(z2)=pr$(rnd(1)*q1):z1=z1+4:goto710
    123. 313 rem ---- konjunktion ----
    124. 314 ifm$="kon"thene$(z2)=ko$(rnd(1)*q3):z1=z1+4:goto710
    125. 315 rem ---- temp. bestimmung ----
    126. 316 ifm$<>"tmp"then320
    127. 318 e$(z2)=ze$(rnd(1)*q2):z1=z1+4:goto710
    128. 319 rem ---- subjekt ----
    129. 320 ifm$<>"sub"then410
    130. 322 ea=val(mid$(w$,z1+3,1)):ed=val(mid$(w$,z1+4,1)):ef=val(mid$(w$,z1+5,1))
    131. 324 ep=val(mid$(w$,z1+6,1))
    132. 326 ifep=2andea=1thenea=2
    133. 328 wa=int(rnd(1)*q4):ge=val(no$(wa,3))-1
    134. 329 ifge=-1thenea=0:ge=0:ed=0:f%=1:goto370
    135. 330 f%=0:ifea<2then340
    136. 331 ifep=1thene$(z2)=ar$(ef*3+ge)
    137. 332 ifep=2thene$(z2)=ar$(ef+12)
    138. 334 z2=z2+1:goto350
    139. 340 ifea=1thene$(z2)="ein"+en$(ef*3+ge):z2=z2+1
    140. 350 ifed=0then370
    141. 351 ifep=2then362
    142. 352 e$(z2)=no$(rnd(1)*q4,2):ifea=0thene$(z2)=e$(z2)+d3$(ef*3+ge)
    143. 354 ifea=1thene$(z2)=e$(z2)+d2$(ef*3+ge)
    144. 356 ifea=2thene$(z2)=e$(z2)+d4$(ef*3+ge)
    145. 360 z2=z2+1:goto370
    146. 362 e$(z2)=no$(rnd(1)*q4,2):ifea=0thene$(z2)=e$(z2)+d3$(ef+12)
    147. 364 ifea=2thene$(z2)=e$(z2)+d4$(ef+12)
    148. 366 z2=z2+1:rem **** substantiv *****
    149. 370 e$(z2)=no$(wa,ep-1):l0$=right$(e$(z2),1):l1$=mid$(e$(z2),len(e$(z2))-1,1)
    150. 371 lz$=mid$(e$(z2),len(e$(z2))-2,1)
    151. 372 vo=0:ifl0$="a"orl0$="e"orl0$="i"orl0$="o"orl0$="u"thenvo=100
    152. 374 ifl1$="a"orl1$="e"orl1$="i"orl1$="o"orl1$="u"thenvo=vo+10
    153. 375 iflz$="a"orlz$="e"orlz$="i"orlz$="o"orlz$="u"thenvo=vo+1
    154. 376 l2$=l0$+l1$:l3$=right$(e$(z2),3)
    155. 378 gosub930:e$(z2)=e$(z2)+ad$:z1=z1+8:goto710
    156. 410 rem ---- verbum ----
    157. 412 ifm$<>"vrb"then430
    158. 414 et=val(mid$(w$,z1+3,1)):ep=val(mid$(w$,z1+4,1))
    159. 416 wa=rnd(1)*q5:if(val(vb$(wa,2))<>et)and(val(vb$(wa,2)))<>2then416
    160. 418 e$(z2)=vb$(wa,ep-1):z1=z1+6:goto710
    161. 430 rem ---- irgendwelche worte -----
    162. 432 ifm$<>"iwo"then440
    163. 434 e$(z2)=iw$(rnd(1)*q6):z1=z1+4:goto710
    164. 440 rem ---- die ---------
    165. 442 ifm$="die"thene$(z2)="die":z1=z1+4:goto710
    166. 444 rem ---- , ----------
    167. 446 ifm$="kom"thene$(z2)=",":z1=z1+4:goto710
    168. 448 rem ---- ist/sind -----
    169. 450 ifm$="ist"thene$(z2)=m$:z1=z1+4:goto710
    170. 452 ifm$="snd"thene$(z2)="sind":z1=z1+4:goto710
    171. 454 rem ---- irgendein subjekt ----
    172. 456 ifm$="kss"thene$(z2)=ks$(rnd(1)*q8):z1=z1+4:goto710
    173. 699 rem ----- ausgabe ---------
    174. 700 print"ERROR...UNKNOWN MNEMONIC:":print" ";m$:end
    175. 710 z2=z2+1:goto306
    176. 712 forx=0toz2-1:p$=p$+e$(x):ife$(x)<>","thenp$=p$+" "
    177. 714 nextx
    178. 722 printleft$(p$,len(p$)-1);"."
    179. 724 ifdr$="j"thenprint#1,left$(p$,len(p$)-1);"."
    180. 730 p$="":nextb:print:ifdr$="j"thenprint#1
    181. 740 forx=0toz2:e$(x)="":next
    182. 750 ifdr$="j"thenprint#1
    183. 760 gosub980:nexta:close1:gosub992:poke198,0:wait198,1:poke198,0
    184. 762 print:print:print" Noch'n Gedicht?"
    185. 764 geta$:ifa$=""then764
    186. 766 ifa$="n"thenrun
    187. 768 ifa$="j"then300
    188. 770 goto764
    189. 800 rem ---- auto -----
    190. 802 print:print" Sie koennen zwischen einem halb- [1]"
    191. 804 print" und einem vollautomatischen [2] Modus"
    192. 806 print" waehlen.Im ersteren muessen Sie"
    193. 808 print" Angaben zur Form des Gedichtes machen, im zweiten nicht.";:gosub980
    194. 810 geta$:ifa$="1"thenprint" halb":goto108
    195. 812 ifa$<>"2"then810
    196. 813 print" voll"
    197. 814 az=int(rnd(ti)*10)+3:r=int(rnd(1)*8)+3:fora=0toaz-1:va%(a)=r:next
    198. 816 fora=0tor-1:b=int(rnd(1)*q0):forc=0toaz-1:mn$(c*r+a)=co$(b):nextc,a
    199. 818 goto300
    200. 900 rem ++ ja/nein ++
    201. 902 ifa$="j"thenprint" ja"
    202. 904 ifa$="n"thenprint" nein"
    203. 906 return
    204. 920 rem ++ zahlen-eingabe ++
    205. 922 kk=0:fora=1to0step-1
    206. 924 geta$:ifa$=chr$(13)thenkk=kk/10:goto928
    207. 925 ifasc(a$+chr$(0))<48orasc(a$+chr$(0))>57then924
    208. 926 printa$;:kk=val(a$)*10^a+kk
    209. 928 next:print:return
    210. 930 rem +++ endung substantiv +++
    211. 932 ad$="":ifep=2then960
    212. 934 onge+1goto936,952,936
    213. 936 onef+1goto952,938,946,953
    214. 937 rem +++ sing.mas.gen +++
    215. 938 ad$="es":ifl0$="e"and(voand110)=100andge=0thenad$="ns":goto945
    216. 939 ifl3$="net"orl2$="rr"thenad$="en":goto945
    217. 940 if(l0$="r"orl0$="n"orl0$="l")and((voand10)=10)thenad$="s":goto945
    218. 941 iff%=1thenad$="s":goto945
    219. 942 ifl0$="s"andvo11<>11thenad$="ses"
    220. 943 ifvo<=1thenad$="es"
    221. 944 ifad$="es"andl0$="e"thenad$="s"
    222. 945 return
    223. 946 rem +++ sing.mas.dat +++
    224. 947 ad$="e":ifl0$="e"thenad$=""
    225. 948 ifl3$="net"orl2$="rr"thenad$="en":goto949
    226. 949 if((l0$="r"orl0$="n"orl0$="l")and(voand10=10))orvo<=1thenad$=""
    227. 950 if(voand110)=100andge=0thenad$="n"
    228. 951 iff%=1thenad$=""
    229. 952 return:rem +++ sing.mas.akk +++
    230. 953 ifl3$="net"orl2$="rr"thenad$="en"
    231. 954 if(voand110)=100andge=0thenad$="n"
    232. 955 iff%=1thenad$=""
    233. 956 return
    234. 960 rem +++ plural +++
    235. 962 ifef<>2then966
    236. 964 ifl0$<>"n"thenad$="n"
    237. 966 return
    238. 970 rem ---- title-sound -----
    239. 972 pokes1+24,15:pokes1+5,15:pokes2+5,15:pokes3+5,15:pokes1+6,247
    240. 974 pokes2+6,247:pokes3+6,247:pokes1+4,17:pokes2+4,17:pokes3+4,17
    241. 976 forv=0to179step5 :pokes1+1,v:pokes2+1,v*5/4:pokes3+1,v*10/7
    242. 978 next:pokes1+4,32:pokes2+4,32:pokes3+4,32:return
    243. 980 rem ---- gong ----
    244. 982 pokes1+24,15+16:pokes1+23,7:pokes1+1,10:pokes1+3,100:pokes1+5,15
    245. 984 pokes1+6,250:pokes2+1,6:pokes2+3,100:pokes2+5,15:pokes2+6,250
    246. 986 pokes3+1,20:pokes3+3,100:pokes3+5,15:pokes3+6,250:pokes1+4,17
    247. 988 pokes2+4,21:pokes3+4,17:fors=1to100:next:pokes1+4,16:pokes2+4,20
    248. 989 pokes3+4,16:return
    249. 990 rem ---- music ----
    250. 992 pokes1,0:pokes2,0:pokes3,0:pokes1+1,0:pokes2+1,0:pokes3+1,0
    251. 993 pokes1+24,15+16:pokes1+23,0:pokes1+5,15:pokes1+6,250:pokes2+5,15
    252. 994 pokes2+6,250:pokes3+5,15:pokes3+6,250:pokes1+4,33:pokes2+4,33
    253. 995 pokes3+4,33:restore:fora=1to5:readh,x1,x2,y1,y2,z1,z2:pokes1+1,x1
    254. 996 pokes1,x2:pokes2+1,y1:pokes2,y2:pokes3+1,z1:pokes3,z2:forb=1toh:nextb,a
    255. 997 pokes1+4,32:pokes2+4,32:pokes3+4,32:return
    256. 998 data 1000,6,133,8,180,10,247,500,9,196,10,247,13,10
    257. 999 data 1000,17,103,14,162,10,247,1500,19,137,26,20,32,219
    258. 1000 data 2000,21,237,26,20,34,207
    259. 1001 rem +++++ satz-strukturen +++++
    260. 1002 data "sub2001 vrb11","der stein erstarrt"
    261. 1003 data "sub2001 und sub2001 vrb12","der stein und das gewebe erstarren"
    262. 1004 data "pra sub1021 vrb12 sub2102","hinter dem Aar fliessen die steine"
    263. 1005 data "sub0102 vrb02 sub1031","Steine schlagen einen Mann"
    264. 1006 data "sub2011 sub0001 vrb11 iwo","des Mannes Hut liegt irgendwo"
    265. 1007 data "kon sub1101 vrb11 kom vrb12 sub2002"
    266. 1008 data "da der Hut ringt,essen die Eier"
    267. 1009 data "iwo vrb01 sub2001 sub2132","Natuerlich toetet Conan die Huete"
    268. 1010 data "sub2102 vrb12 kom kon sub1001 sub2131 vrb21"
    269. 1011 data "Der Hut eiert,weil die Frau das Wasser trinkt"
    270. 1012 data "sub0002 und sub0002 kom sub2001 vrb11"
    271. 1013 data "Hexen und Teufel,der Weg verweht"
    272. 1014 data "sub0002 kom die vrb12","Planeten,die vergehen"
    273. 1015 data "kon iwo sub2001 vrb11 kom vrb12 sub2002 und sub2002"
    274. 1016 data "Weil kein Wolf schwebt,schlafen die Huete und die Eier"
    275. 1017 data "sub2001 kom sub1101 kom vrb01 sub0032"
    276. 1018 data "der Hund,ein blaues Tier,toetet Pferde"
    277. 1019 data "tmp vrb11 sub2101","bald ertrinkt Conan"
    278. 1020 data "tmp ist sub2001 sub1101","nun ist der Hut ein blauer Fleck"
    279. 1021 data "sub0002 vrb12 pra sub2021","Herzen rieseln in dem Licht"
    280. 1022 data "sub2001 vrb11 kom kon sub2001 vrb11"
    281. 1023 data "die Freude funkelt,wenn der Becher duftet"
    282. 1050 data "sub2002 snd sub0102 kom kon sub2001 vrb11"
    283. 1051 data "die Baeren sind gruene Aepfel,weil der Hut eiert"
    284. 1052 data "sub0002 kom sub0002 kom sub0002 kom kss vrb11"
    285. 1053 data "Aepfel,Birnen,Wirbel,alles vergeht"
    286. 1054 data "kon sub2002 vrb12 kom ist sub2001 sub1101"
    287. 1055 data "weil der Hut singt,ist der Mann eine Bestie"
    288. 1500 data @@@,@@@
    289. 2000 rem +++++ deklinationen +++++++
    290. 2002 data @1,,e,,es,er,es,em,er,em,en,e,
    291. 2004 data e,er,en,e
    292. 2010 rem +++++ deklinationen +++++++
    293. 2012 data r,,s,n,n,n,n,n,n,n,,s:rem ein
    294. 2014 rem +++++ deklinationen +++++++
    295. 2016 data r,,s,n,r,n,m,r,m,n,,s,,r,n,:rem nil
    296. 2017 rem +++++ deklinationen +++++++
    297. 2018 data ,,,n,n,n,n,n,n,n,,,n,n,n,n:rem der
    298. 2020 rem +++++ best. artikel +++++++
    299. 2022 data der,die,das,des,der,des,dem,der,dem,den,die,das
    300. 2024 data die,der,den,die
    301. 2030 rem +++++ endsilben +++++++
    302. 2040 rem +++++ praepositionen ++++++
    303. 2042 data in,auf,neben,unter,ueber,gegenueber,an,aus
    304. 2060 rem +++++ tmp. bestimmungen +++
    305. 2064 data jetzt,nun,heute,soeben,bald,gleich
    306. 2080 rem +++++ konjunktionen +++++++
    307. 2082 data wenn,da,weil,da ja,weil nun einmal,obgleich,obwohl
    308. 2084 data auch wenn,wenn auch,waehrend,solange,solange bis
    309. 2086 data nachdem,seitdem,eher als,als,bevor,jedesmal wenn
    310. 2088 data wie sehr auch,wenn aber,wenn nur,wenn nur nicht
    311. 2090 data damit,damit nicht,sobald
    312. 2100 rem +++++ einfach worte ++++++++
    313. 2102 data "immer wieder",andauernd,"ohne unterlass","nur noch"
    314. 2104 data niemals,seltsamerweise,manchmal,"wieder und wieder"
    315. 2105 data "zu keiner zeit","fuer immer und ewig"
    316. 2120 rem +++++ diverse substantive ++++
    317. 2122 data nichts,alles,"rein gar nichts","kaum etwas",niemand,alle
    318. 2200 rem +++++ nomen,adjektive ++++++
    319. 2201 data meer,meere,waessrige,3
    320. 2202 data wald,waelder,gruene,1
    321. 2203 data haus,haeuser,blaue,3
    322. 2204 data maedchen,maedchen,helle,3
    323. 2205 data junge,jungen,junge,1
    324. 2206 data frau,frauen,dunkle,2
    325. 2207 data turm,tuerme,durstige,1
    326. 2208 data mann,maenner,trockene,1
    327. 2209 data planet,planeten,runde,1
    328. 2210 data wueste,wuesten,kalte,2
    329. 2211 data kaelte,winde,warme,2
    330. 2212 data grab,graeber,eiskalte,3
    331. 2213 data glocke,glocken,goldene,2
    332. 2214 data feld,felder,alte,3
    333. 2215 data see,leute,feuchte,1
    334. 2216 data herr,herren,praechtige,1
    335. 2217 data weg,wege,gefaehrliche,1
    336. 2218 data tier,tiere,graue,3
    337. 2219 data welt,welten,schwarze,2
    338. 2220 data land,laender,leuchtende,3
    339. 2221 data kraehe,kraehen,tote,2
    340. 2222 data schlacht,schlachten,prasselnde,2
    341. 2223 data luft,luefte,silberne,2
    342. 2224 data macht,maechte,maechtige,2
    343. 2225 data ring,ringe,uralte,1
    344. 2226 data steintuer,pfade,weise,2
    345. 2227 data zauberer,zauberer,einsame,1
    346. 2228 data wolf,woelfe,heulende,1
    347. 2229 data feuer,feuer,brennende,3
    348. 2230 data wolke,wolken,weisse,2
    349. 2231 data wirbel,wirbel,reissende,1
    350. 2232 data welle,wellen,nasse,2
    351. 2233 data stern,sterne,strahlende,1
    352. 2234 data pferd,pferde,stolze,3
    353. 2235 data tor,tore,gewaltige,3
    354. 2236 data festung,festungen,starke,2
    355. 2237 data hoffnung,hoffnungen,muehsame,2
    356. 2238 data pflicht,pflichten,ernste,2
    357. 2239 data auge,augen,magische,3
    358. 2240 data zweifel,zweifel,uralte,1
    359. 2241 data sterben,schicksale,unendliche,3
    360. 2242 data gang,gaenge,unirdische,1
    361. 2243 data verzweifelung,stimmen,grausame,2
    362. 2244 data wirklichkeit,voelker,unwirkliche,2
    363. 2245 data denken,gedanken,denkbare,3
    364. 2246 data ork,orks,giftige,1
    365. 2247 data schlange,voegel,gefiederte,2
    366. 2248 data ende,lichter,duestere,3
    367. 2249 data blick,blicke,unwuerdige,1
    368. 2250 data fenster,fenster,fensterlose,3
    369. 2251 data tod,hoerner,lauernde,1
    370. 2252 data rauch,waende,dunstige,1
    371. 2253 data krieg,kriege,verfluchte,1
    372. 2254 data klirren,horden,metallene,3
    373. 2255 data wagnis,gaben,finstere,3
    374. 2256 data leben,gegner,toetliche,3
    375. 2257 data stein,steine,fluesternde,1
    376. 2258 data kette,ketten,schwere,2
    377. 2259 data fluss,fluesse,spitze,1
    378. 2260 data wille,schwerter,glaenzende,1
    379. 2261 data ross,roesser,schicksalshafte,3
    380. 2262 data gasthaus,reiter,unbekannte,3
    381. 2263 data tapferkeit,faehigkeiten,edle,2
    382. 2264 data crom,goetter,verlorene,0
    383. 2265 data falke,falken,stuerzende,1
    384. 2266 data conan,teufel,hetzende,0
    385. 2267 data schwert,katzen,schleichende,3
    386. 2268 data freude,freuden,stinkende,2
    387. 2269 data glitzern,bestien,blutige,3
    388. 2270 data drache,drachen,gigantische,1
    389. 2271 data blitz,blitze,grelle,1
    390. 2272 data schrecken,schrecken,blutruenstige,1
    391. 2273 data moor,suempfe,tropfende,3
    392. 2274 data mond,monde,suechtige,1
    393. 2275 data eber,mauern,wilde,1
    394. 2276 data rabe,raben,pechschwarze,1
    395. 2277 data einsamkeit,zweige,dumpfe,2
    396. 2278 data geheimnis,geheimnisse,vergessene,3
    397. 2279 data verlangen,wiesen,ekstatische,3
    398. 2280 data messer,messer,scharfe,3
    399. 2281 data mauer,mauern,steinerne,2
    400. 2282 data magie,zaubereien,erdfarbene,2
    401. 2283 data pest,ketten,staehlerne,2
    402. 2284 data waffe,waffen,verborgene,2
    403. 2285 data hund,hunde,reissende,1
    404. 2286 data monument,kunstlehrer,gerissene,3
    405. 2287 data malte,"lippe enterprises",berechtigte,0
    406. 2288 data matthias,monumente,irdene,0
    407. 2289 data stefan,eindruecke,gewaltige,0
    408. 2290 data dirk,visionen,farblose,0
    409. 2291 data bauer,bauern,weiche,1
    410. 2292 data uebermensch,giganten,knorrige,1
    411. 2293 data wahnsinn,centauren,stierkoepfige,1
    412. 2294 data richter,richter,pulsierende,1
    413. 2295 data sonne,sonnen,berstende,2
    414. 2296 data galaxis,galaxien,"strahlend schoene",2
    415. 2297 data weltenkreis,fragen,groesste,1
    416. 2298 data impuls,impulse,rotierende,1
    417. 2299 data pulsar,pulsare,grenzenlose,1
    418. 2300 data supernova,supernovae,unermessliche,2
    419. 2301 data vakuum,fragmente,erheiterte,3
    420. 2302 data kugelraumer,kugelraumer,waffenstarrende,1
    421. 2303 data zyklus,zyklen,barbarische,1
    422. 2304 data schmerz,schmerzen,ruhende,1
    423. 2305 data geschuetz,geschuetze,rauchende,3
    424. 2306 data wall,waelle,mentale,1
    425. 2307 data schwertmeister,herausforderer,riesige,1
    426. 2308 data revolte,revolten,gewaltlose,2
    427. 2309 data komet,kometen,gefrorene,1
    428. 2310 data meteor,meteore,"hell gluehende",1
    429. 2311 data gas,gase,betaeubende,3
    430. 2312 data raumschiff,raumschiffe,stellare,3
    431. 2313 data stern,sterne,drohende,1
    432. 2314 data masse,massen,starre,2
    433. 2315 data energie,energien,reine,2
    434. 2316 data zeit,zeiten,vergluehende,2
    435. 2317 data raum,raeume,erneuerte,1
    436. 2318 data raum-zeit,gefuehle,fliessende,2
    437. 2319 data traegheit,oberflaechen,zerschmolzene,2
    438. 2320 data kugel,kugeln,seltsame,2
    439. 2321 data monolith,monolithen,kristalline,1
    440. 2322 data quader,quader,interstellare,3
    441. 2323 data quasar,quasare,archaische,1
    442. 2324 data herrscher,herrscher,faszinierende,1
    443. 2325 data kosmos,daempfe,heisse,1
    444. 2326 data universum,kreise,silberne,3
    445. 2327 data jungfrau,jungfrauen,stilisierte,2
    446. 2328 data tropfen,tropfen,tropfende,1
    447. 2329 data matrix,matrizen,kubische,2
    448. 2330 data kalkuel,kalkuele,dogmatische,3
    449. 2331 data experiment,experimente,grauenhafte,3
    450. 2332 data haselnuss,haselnuesse,astrale,2
    451. 2333 data gesang,gesaenge,meditative,1
    452. 2334 data droge,drogen,psychedelische,2
    453. 2335 data angst,aengste,hysterische,2
    454. 2336 data sitar,geraeusche,morbide,1
    455. 2337 data erkenntnis,erkenntnisse,indische,3
    456. 2338 data sturm,stuerme,goettliche,1
    457. 6000 rem +++++ verben +++++++++++++++
    458. 6001 data bestaunt,bestaunen,0
    459. 6002 data zerfliesst,zerfliessen,1
    460. 6003 data rieselt,rieseln,1
    461. 6004 data erstarrt,erstarren,1
    462. 6005 data zerbricht,zerbrechen,2
    463. 6006 data zerschmettert,zerschmettern,2
    464. 6007 data trinkt,trinken,3
    465. 6008 data schlaeft,schlafen,1
    466. 6009 data wandert,wandern,1
    467. 6010 data fliegt,fliegen,1
    468. 6011 data kaempft,kaempfen,1
    469. 6012 data bekaempft,bekaempfen,0
    470. 6013 data zerfaellt,zerfallen,1
    471. 6014 data zerfrisst,zerfressen,0
    472. 6015 data lacht,lachen,1
    473. 6016 data winkt,winken,1
    474. 6017 data flucht,fluchen,1
    475. 6018 data toetet,toeten,2
    476. 6019 data entflammt,entflammen,1
    477. 6020 data stolpert,stolpern,1
    478. 6021 data kreischt,kreischen,1
    479. 6022 data knurrt,knurren,1
    480. 6023 data verweht,verwehen,1
    481. 6024 data bewegt,bewegen,0
    482. 6025 data durchbohrt,durchbohren,0
    483. 6026 data schreit,schreien,1
    484. 6027 data erduldet,erdulden,0
    485. 6028 data fluechtet,fluechten,1
    486. 6029 data erschlaegt,erschlagen,0
    487. 6030 data vergeht,vergehen,1
    488. 6031 data kreist,kreisen,1
    489. 6032 data glueht,gluehen,1
    490. 6033 data schwebt,schweben,1
    491. 6034 data steigt,steigen,1
    492. 6035 data schwankt,schwanken,1
    493. 6036 data sinkt,sinken,1
    494. 6037 data beklagt,beklagen,0
    495. 6038 data stuerzt,stuerzen,1
    496. 6039 data verliert,verlieren,2
    497. 6040 data beerdigt,beerdigen,0
    498. 6041 data verwundert,verwundern,0
    499. 6042 data fordert,fordern,2
    500. 6043 data bezwingt,bezwingen,0
    501. 6044 data fuehrt,fuehren,2
    502. 6045 data zweifelt,zweifeln,1
    503. 6046 data begehrt,begehren,0
    504. 6047 data verwandelt,verwandeln,0
    505. 6048 data erschafft,erschaffen,0
    506. 6049 data teilt,teilen,0
    507. 6050 data vermodert,vermodern,1
    508. 6051 data versinkt,versinken,1
    509. 6052 data beschwoert,beschwoeren,0
    510. 6053 data funkelt,funkeln,1
    511. 6054 data duftet,duften,1
    512. 6055 data gefriert,gefrieren,1
    513. 6056 data erfriert,erfrieren,1
    514. 6057 data verlaesst,verlassen,0
    515. 6058 data zersplittert,zersplittern,1
    516. 6059 data zersticht,zerstechen,0
    517. 6060 data zerreisst,zerreissen,0
    518. 6061 data verbrennt,verbrennen,2
    519. 6062 data opfert,opfern,2
    520. 6063 data zerfetzt,zerfetzen,0
    521. 6064 data prahlt,prahlen,1
    522. 6065 data beendet,beenden,0
    523. 6066 data erlangt,erlangen,0
    524. 6067 data erblickt,erblicken,0
    525. 6068 data verfolgt,verfolgen,0
    526. 6069 data seufzt,seufzen,1
    527. 6070 data spuert,spueren,0
    528. 6071 data vermeidet,vermeiden,0
    529. 6072 data singt,singen,1
    530. 6073 data besingt,besingen,0
    531. 6074 data beweint,beweinen,0
    532. 6075 data vergisst,vergessen,3
    533. 6076 data beruehrt,beruehren,0
    534. 6077 data erklingt,erklingen,1
    535. 6078 data verglueht,vergluehen,1
    536. 6079 data lebt,leben,1
    537. 6080 data sucht,suchen,0
    538. 6081 data verkuendet,verkuenden,0
    539. 6082 data erwacht,erwachen,1
    540. 6083 data glaenzt,glaenzen,1
    541. 6084 data huetet,hueten,0
    542. 6085 data betrachtet,betrachten,0
    543. 6086 data laechelt,laecheln,1
    544. 6087 data rotiert,rotieren,1
    545. 6088 data durchwandert,durchwandern,0
    546. 6089 data schimmert,schimmern,1
    547. 6090 data antwortet,antworten,1
    Alles anzeigen


    ...und das Kompilat:

    Quellcode

    1. 1:
    2. NOP
    3. 2:
    4. NOP
    5. 3:
    6. NOP
    7. 4:
    8. NOP
    9. 5:
    10. NOP
    11. 6:
    12. NOP
    13. 7:
    14. NOP
    15. 8:
    16. NOP
    17. 9:
    18. NOP
    19. 10:
    20. NOP
    21. 11:
    22. NOP
    23. 12:
    24. MOV Y,#19{INTEGER}
    25. MOV Q0{REAL},Y
    26. NOP
    27. 13:
    28. MOV Y,#8{INTEGER}
    29. MOV Q1{REAL},Y
    30. NOP
    31. 14:
    32. MOV Y,#6{INTEGER}
    33. MOV Q2{REAL},Y
    34. NOP
    35. 15:
    36. MOV Y,#25{INTEGER}
    37. MOV Q3{REAL},Y
    38. NOP
    39. 16:
    40. MOV Y,#138{INTEGER}
    41. MOV Q4{REAL},Y
    42. NOP
    43. 17:
    44. MOV Y,#90{INTEGER}
    45. MOV Q5{REAL},Y
    46. NOP
    47. 18:
    48. MOV Y,#10{INTEGER}
    49. MOV Q6{REAL},Y
    50. NOP
    51. 19:
    52. MOV Y,#8{INTEGER}
    53. MOV Q7{REAL},Y
    54. NOP
    55. 20:
    56. MOV Y,#6{INTEGER}
    57. MOV Q8{REAL},Y
    58. NOP
    59. 21:
    60. MOV Y,#53281{INTEGER}
    61. PUSH Y
    62. MOV X,#14{INTEGER}
    63. POP Y
    64. MOV (Y),X
    65. MOV Y,#53280{INTEGER}
    66. PUSH Y
    67. MOV X,#6{INTEGER}
    68. POP Y
    69. MOV (Y),X
    70. JSR COMPACT
    71. MOV Y,#147{INTEGER}
    72. CHGCTX #1
    73. JSR CHR
    74. JSR STROUT
    75. JSR COMPACT
    76. MOV Y,#14{INTEGER}
    77. CHGCTX #1
    78. JSR CHR
    79. JSR STROUT
    80. JSR COMPACT
    81. MOV Y,#8{INTEGER}
    82. CHGCTX #1
    83. JSR CHR
    84. JSR STROUT
    85. JSR LINEBREAK
    86. 22:
    87. 24:
    88. 26:
    89. 28:
    90. MOV Y,#54272{INTEGER}
    91. MOV S1{REAL},Y
    92. MOV Y,#7{INTEGER}
    93. MOV X,S1{REAL}
    94. ADD X,Y
    95. MOV S2{REAL},X
    96. MOV Y,#7{INTEGER}
    97. MOV X,S2{REAL}
    98. ADD X,Y
    99. MOV S3{REAL},X
    100. MOV Y,#24{INTEGER}
    101. PUSH Y
    102. MOV Y,#1{INTEGER}
    103. PUSH Y
    104. MOV Y,#0{INTEGER}
    105. MOV A{REAL},Y
    106. MOV A,(A{REAL})
    107. JSR INITFOR
    108. MOV Y,A{REAL}
    109. MOV X,S1{REAL}
    110. ADD X,Y
    111. PUSH X
    112. MOV X,#0{INTEGER}
    113. POP Y
    114. MOV (Y),X
    115. MOV A,#0{INTEGER}
    116. JSR NEXT
    117. CMP A,#0{INTEGER}
    118. JE ($JUMP)
    119. 29:
    120. MOV Y,#20{INTEGER}
    121. PUSH Y
    122. MOV Y,#1{INTEGER}
    123. PUSH Y
    124. MOV Y,#1{INTEGER}
    125. MOV A{REAL},Y
    126. MOV A,(A{REAL})
    127. JSR INITFOR
    128. MOV Y,#0{INTEGER}
    129. PUSH Y
    130. MOV Y,#-1.0{REAL}
    131. PUSH Y
    132. MOV Y,#1{INTEGER}
    133. MOV B{REAL},Y
    134. MOV A,(B{REAL})
    135. JSR INITFOR
    136. MOV Y,#646{INTEGER}
    137. PUSH Y
    138. MOV X,B{REAL}
    139. POP Y
    140. MOV (Y),X
    141. MOV Y,#24{INTEGER}
    142. MOV X,S1{REAL}
    143. ADD X,Y
    144. PUSH X
    145. MOV X,#0{INTEGER}
    146. POP Y
    147. MOV (Y),X
    148. MOV Y,#24{INTEGER}
    149. MOV X,S1{REAL}
    150. ADD X,Y
    151. PUSH X
    152. MOV X,#15{INTEGER}
    153. POP Y
    154. MOV (Y),X
    155. 30:
    156. JSR LINEBREAK
    157. JSR COMPACT
    158. MOV A,# Dirk Meier's Lyric 3.0{STRING}
    159. JSR STROUT
    160. JSR LINEBREAK
    161. JSR COMPACT
    162. MOV A,# ======================{STRING}
    163. JSR STROUT
    164. JSR LINEBREAK
    165. MOV A,(B{})
    166. JSR NEXT
    167. CMP A,#0{INTEGER}
    168. JE ($JUMP)
    169. MOV A,(A{})
    170. JSR NEXT
    171. CMP A,#0{INTEGER}
    172. JE ($JUMP)
    173. 31:
    174. MOV Y,#646{INTEGER}
    175. PUSH Y
    176. MOV X,#1{INTEGER}
    177. POP Y
    178. MOV (Y),X
    179. JSR LINEBREAK
    180. JSR COMPACT
    181. MOV A,# Ein Gedicht-Synthese Programm.{STRING}
    182. JSR STROUT
    183. JSR LINEBREAK
    184. 32:
    185. JSR LINEBREAK
    186. JSR COMPACT
    187. MOV A,# Entwickelt nach naechtelangen{STRING}
    188. JSR STROUT
    189. JSR LINEBREAK
    190. 34:
    191. JSR COMPACT
    192. MOV A,# Schlachten mit der deutschen Grammatik.{STRING}
    193. JSR STROUT
    194. JSR LINEBREAK
    195. 36:
    196. JSR COMPACT
    197. MOV A,# Greetings to Storm,Borchert,Fried,Astel und Enzensberger...{STRING}
    198. JSR STROUT
    199. JSR LINEBREAK
    200. 38:
    201. JSR LINEBREAK
    202. JSR COMPACT
    203. MOV A,# But never forget:{STRING}
    204. JSR STROUT
    205. JSR LINEBREAK
    206. JSR COMPACT
    207. MOV A,# Keep it heavy and keep it hard...{STRING}
    208. JSR STROUT
    209. JSR LINEBREAK
    210. 40:
    211. JSR LINEBREAK
    212. JSR COMPACT
    213. MOV A,# Aber jetzt: NIL NISI OPTIMUS !{STRING}
    214. JSR STROUT
    215. JSR LINEBREAK
    216. JSR LINEBREAK
    217. 44:
    218. JSR COMPACT
    219. MOV Y,#18{INTEGER}
    220. CHGCTX #1
    221. JSR CHR
    222. JSR STROUT
    223. JSR COMPACT
    224. MOV A,# Ich warte auf eine Reaktion von Ihnen {STRING}
    225. JSR STROUT
    226. JSR LINEBREAK
    227. 46:
    228. JSR GETSTR
    229. MOV A${STRING},A
    230. JSR COMPACT
    231. MOV B,#{STRING}
    232. MOV A,A${STRING}
    233. CHGCTX #0
    234. JSR SEQ
    235. CMP X,#0{REAL}
    236. JE SKIP18
    237. JMP 46
    238. SKIP18:
    239. 47:
    240. JSR GOSUB
    241. JSR 970
    242. JSR COMPACT
    243. MOV Y,#18{INTEGER}
    244. CHGCTX #1
    245. JSR CHR
    246. JSR STROUT
    247. JSR COMPACT
    248. MOV A,# Bitte etwas warten {STRING}
    249. JSR STROUT
    250. JSR LINEBREAK
    251. 49:
    252. MOV Y,#35{INTEGER}
    253. PUSH Y
    254. MOV Y,#1{INTEGER}
    255. PUSH Y
    256. MOV Y,#1{INTEGER}
    257. MOV A{REAL},Y
    258. MOV A,(A{REAL})
    259. JSR INITFOR
    260. JSR READSTR
    261. MOV A${STRING},A
    262. MOV A,#0{INTEGER}
    263. JSR NEXT
    264. CMP A,#0{INTEGER}
    265. JE ($JUMP)
    266. 50:
    267. MOV Y,#1{INTEGER}
    268. MOV X,Q0{REAL}
    269. SUB X,Y
    270. PUSH X
    271. MOV Y,#1{INTEGER}
    272. PUSH Y
    273. MOV Y,#0{INTEGER}
    274. MOV A{REAL},Y
    275. MOV A,(A{REAL})
    276. JSR INITFOR
    277. MOV Y,A{REAL}
    278. PUSH Y
    279. JSR READSTR
    280. POP X
    281. MOV G,CO$[]{STRING}
    282. JSR ARRAYSTORE
    283. JSR READSTR
    284. MOV A${STRING},A
    285. MOV A,#0{INTEGER}
    286. JSR NEXT
    287. CMP A,#0{INTEGER}
    288. JE ($JUMP)
    289. JSR READSTR
    290. MOV A${STRING},A
    291. JSR READSTR
    292. MOV A${STRING},A
    293. JSR READSTR
    294. MOV A${STRING},A
    295. 52:
    296. MOV Y,#15{INTEGER}
    297. PUSH Y
    298. MOV Y,#1{INTEGER}
    299. PUSH Y
    300. MOV Y,#0{INTEGER}
    301. MOV A{REAL},Y
    302. MOV A,(A{REAL})
    303. JSR INITFOR
    304. MOV Y,A{REAL}
    305. PUSH Y
    306. JSR READSTR
    307. POP X
    308. MOV G,EN$[]{STRING}
    309. JSR ARRAYSTORE
    310. MOV A,#0{INTEGER}
    311. JSR NEXT
    312. CMP A,#0{INTEGER}
    313. JE ($JUMP)
    314. NOP
    315. 53:
    316. MOV Y,#11{INTEGER}
    317. PUSH Y
    318. MOV Y,#1{INTEGER}
    319. PUSH Y
    320. MOV Y,#0{INTEGER}
    321. MOV A{REAL},Y
    322. MOV A,(A{REAL})
    323. JSR INITFOR
    324. MOV Y,A{REAL}
    325. PUSH Y
    326. JSR READSTR
    327. POP X
    328. MOV G,D2$[]{STRING}
    329. JSR ARRAYSTORE
    330. MOV A,#0{INTEGER}
    331. JSR NEXT
    332. CMP A,#0{INTEGER}
    333. JE ($JUMP)
    334. NOP
    335. 54:
    336. MOV Y,#15{INTEGER}
    337. PUSH Y
    338. MOV Y,#1{INTEGER}
    339. PUSH Y
    340. MOV Y,#0{INTEGER}
    341. MOV A{REAL},Y
    342. MOV A,(A{REAL})
    343. JSR INITFOR
    344. MOV Y,A{REAL}
    345. PUSH Y
    346. JSR READSTR
    347. POP X
    348. MOV G,D3$[]{STRING}
    349. JSR ARRAYSTORE
    350. MOV A,#0{INTEGER}
    351. JSR NEXT
    352. CMP A,#0{INTEGER}
    353. JE ($JUMP)
    354. NOP
    355. 55:
    356. MOV Y,#15{INTEGER}
    357. PUSH Y
    358. MOV Y,#1{INTEGER}
    359. PUSH Y
    360. MOV Y,#0{INTEGER}
    361. MOV A{REAL},Y
    362. MOV A,(A{REAL})
    363. JSR INITFOR
    364. MOV Y,A{REAL}
    365. PUSH Y
    366. JSR READSTR
    367. POP X
    368. MOV G,D4$[]{STRING}
    369. JSR ARRAYSTORE
    370. MOV A,#0{INTEGER}
    371. JSR NEXT
    372. CMP A,#0{INTEGER}
    373. JE ($JUMP)
    374. NOP
    375. 56:
    376. MOV Y,#15{INTEGER}
    377. PUSH Y
    378. MOV Y,#1{INTEGER}
    379. PUSH Y
    380. MOV Y,#0{INTEGER}
    381. MOV A{REAL},Y
    382. MOV A,(A{REAL})
    383. JSR INITFOR
    384. MOV Y,A{REAL}
    385. PUSH Y
    386. JSR READSTR
    387. POP X
    388. MOV G,AR$[]{STRING}
    389. JSR ARRAYSTORE
    390. MOV A,#0{INTEGER}
    391. JSR NEXT
    392. CMP A,#0{INTEGER}
    393. JE ($JUMP)
    394. NOP
    395. 58:
    396. MOV Y,#1{INTEGER}
    397. MOV X,Q1{REAL}
    398. SUB X,Y
    399. PUSH X
    400. MOV Y,#1{INTEGER}
    401. PUSH Y
    402. MOV Y,#0{INTEGER}
    403. MOV A{REAL},Y
    404. MOV A,(A{REAL})
    405. JSR INITFOR
    406. MOV Y,A{REAL}
    407. PUSH Y
    408. JSR READSTR
    409. POP X
    410. MOV G,PR$[]{STRING}
    411. JSR ARRAYSTORE
    412. MOV A,#0{INTEGER}
    413. JSR NEXT
    414. CMP A,#0{INTEGER}
    415. JE ($JUMP)
    416. NOP
    417. 59:
    418. MOV Y,#1{INTEGER}
    419. MOV X,Q2{REAL}
    420. SUB X,Y
    421. PUSH X
    422. MOV Y,#1{INTEGER}
    423. PUSH Y
    424. MOV Y,#0{INTEGER}
    425. MOV B{REAL},Y
    426. MOV A,(B{REAL})
    427. JSR INITFOR
    428. MOV Y,B{REAL}
    429. PUSH Y
    430. JSR READSTR
    431. POP X
    432. MOV G,ZE$[]{STRING}
    433. JSR ARRAYSTORE
    434. MOV A,(B{})
    435. JSR NEXT
    436. CMP A,#0{INTEGER}
    437. JE ($JUMP)
    438. NOP
    439. 60:
    440. MOV Y,#1{INTEGER}
    441. MOV X,Q3{REAL}
    442. SUB X,Y
    443. PUSH X
    444. MOV Y,#1{INTEGER}
    445. PUSH Y
    446. MOV Y,#0{INTEGER}
    447. MOV A{REAL},Y
    448. MOV A,(A{REAL})
    449. JSR INITFOR
    450. MOV Y,A{REAL}
    451. PUSH Y
    452. JSR READSTR
    453. POP X
    454. MOV G,KO$[]{STRING}
    455. JSR ARRAYSTORE
    456. MOV A,#0{INTEGER}
    457. JSR NEXT
    458. CMP A,#0{INTEGER}
    459. JE ($JUMP)
    460. NOP
    461. 61:
    462. MOV Y,#1{INTEGER}
    463. MOV X,Q6{REAL}
    464. SUB X,Y
    465. PUSH X
    466. MOV Y,#1{INTEGER}
    467. PUSH Y
    468. MOV Y,#0{INTEGER}
    469. MOV A{REAL},Y
    470. MOV A,(A{REAL})
    471. JSR INITFOR
    472. MOV Y,A{REAL}
    473. PUSH Y
    474. JSR READSTR
    475. POP X
    476. MOV G,IW$[]{STRING}
    477. JSR ARRAYSTORE
    478. MOV A,#0{INTEGER}
    479. JSR NEXT
    480. CMP A,#0{INTEGER}
    481. JE ($JUMP)
    482. NOP
    483. 62:
    484. MOV Y,#1{INTEGER}
    485. MOV X,Q8{REAL}
    486. SUB X,Y
    487. PUSH X
    488. MOV Y,#1{INTEGER}
    489. PUSH Y
    490. MOV Y,#0{INTEGER}
    491. MOV A{REAL},Y
    492. MOV A,(A{REAL})
    493. JSR INITFOR
    494. MOV Y,A{REAL}
    495. PUSH Y
    496. JSR READSTR
    497. POP X
    498. MOV G,KS$[]{STRING}
    499. JSR ARRAYSTORE
    500. MOV A,(A{})
    501. JSR NEXT
    502. CMP A,#0{INTEGER}
    503. JE ($JUMP)
    504. NOP
    505. 63:
    506. MOV Y,#1{INTEGER}
    507. MOV X,Q4{REAL}
    508. SUB X,Y
    509. PUSH X
    510. MOV Y,#1{INTEGER}
    511. PUSH Y
    512. MOV Y,#0{INTEGER}
    513. MOV A{REAL},Y
    514. MOV A,(A{REAL})
    515. JSR INITFOR
    516. MOV Y,#3{INTEGER}
    517. PUSH Y
    518. MOV Y,#1{INTEGER}
    519. PUSH Y
    520. MOV Y,#0{INTEGER}
    521. MOV B{REAL},Y
    522. MOV A,(B{REAL})
    523. JSR INITFOR
    524. MOV Y,#138{INTEGER}
    525. MOV X,B{REAL}
    526. MUL X,Y
    527. MOV Y,X
    528. MOV X,A{REAL}
    529. ADD X,Y
    530. PUSH X
    531. JSR READSTR
    532. POP X
    533. MOV G,NO$[]{STRING}
    534. JSR ARRAYSTORE
    535. MOV A,(B{})
    536. JSR NEXT
    537. CMP A,#0{INTEGER}
    538. JE ($JUMP)
    539. MOV A,(A{})
    540. JSR NEXT
    541. CMP A,#0{INTEGER}
    542. JE ($JUMP)
    543. NOP
    544. 64:
    545. MOV Y,#1{INTEGER}
    546. MOV X,Q5{REAL}
    547. SUB X,Y
    548. PUSH X
    549. MOV Y,#1{INTEGER}
    550. PUSH Y
    551. MOV Y,#0{INTEGER}
    552. MOV A{REAL},Y
    553. MOV A,(A{REAL})
    554. JSR INITFOR
    555. MOV Y,#2{INTEGER}
    556. PUSH Y
    557. MOV Y,#1{INTEGER}
    558. PUSH Y
    559. MOV Y,#0{INTEGER}
    560. MOV B{REAL},Y
    561. MOV A,(B{REAL})
    562. JSR INITFOR
    563. MOV Y,#90{INTEGER}
    564. MOV X,B{REAL}
    565. MUL X,Y
    566. MOV Y,X
    567. MOV X,A{REAL}
    568. ADD X,Y
    569. PUSH X
    570. JSR READSTR
    571. POP X
    572. MOV G,VB$[]{STRING}
    573. JSR ARRAYSTORE
    574. MOV A,(B{})
    575. JSR NEXT
    576. CMP A,#0{INTEGER}
    577. JE ($JUMP)
    578. MOV A,(A{})
    579. JSR NEXT
    580. CMP A,#0{INTEGER}
    581. JE ($JUMP)
    582. NOP
    583. 100:
    584. JSR GOSUB
    585. JSR 970
    586. JSR COMPACT
    587. MOV Y,#147{INTEGER}
    588. CHGCTX #1
    589. JSR CHR
    590. JSR STROUT
    591. JSR COMPACT
    592. MOV A,# Ausdrucken lassen wollen Sie Sich die{STRING}
    593. JSR STROUT
    594. JSR LINEBREAK
    595. 102:
    596. JSR COMPACT
    597. MOV A,# Gedichte doch sicherlich...oder ?{STRING}
    598. JSR STROUT
    599. JSR LINEBREAK
    600. JSR GOSUB
    601. JSR 980
    602. 105:
    603. JSR GETSTR
    604. MOV DR${STRING},A
    605. JSR COMPACT
    606. MOV B,#n{STRING}
    607. MOV A,DR${STRING}
    608. CHGCTX #0
    609. JSR SNEQ
    610. PUSH X
    611. CHGCTX #1
    612. MOV B,#j{STRING}
    613. MOV A,DR${STRING}
    614. CHGCTX #0
    615. JSR SNEQ
    616. POP Y
    617. AND X,Y
    618. CMP X,#0{REAL}
    619. JE SKIP19
    620. JMP 105
    621. SKIP19:
    622. 107:
    623. JSR COMPACT
    624. MOV B,DR${STRING}
    625. MOV A${STRING},B
    626. JSR GOSUB
    627. JSR 900
    628. JMP 800
    629. 108:
    630. JSR LINEBREAK
    631. JSR COMPACT
    632. MOV A,# Kommen wir zu dem Aufbau der Strophen.{STRING}
    633. JSR STROUT
    634. JSR LINEBREAK
    635. 109:
    636. JSR COMPACT
    637. MOV A,# Wie viele Strophen sollen es sein ?{STRING}
    638. JSR STROUT
    639. JSR GOSUB
    640. JSR 980
    641. 110:
    642. JSR GOSUB
    643. JSR 920
    644. MOV Y,KK{REAL}
    645. MOV AZ{REAL},Y
    646. MOV Y,#1{INTEGER}
    647. MOV X,AZ{REAL}
    648. EQ X,Y
    649. CMP X,#0{REAL}
    650. JE SKIP20
    651. JMP 122
    652. SKIP20:
    653. 111:
    654. MOV Y,#1{INTEGER}
    655. MOV X,AZ{REAL}
    656. LT X,Y
    657. CMP X,#0{REAL}
    658. JE SKIP21
    659. JSR LINEBREAK
    660. JMP 110
    661. SKIP21:
    662. 112:
    663. JSR LINEBREAK
    664. JSR COMPACT
    665. MOV A,# Sollen alle {STRING}
    666. JSR STROUT
    667. MOV X,AZ{REAL}
    668. JSR REALOUT
    669. MOV A,# {STRING}
    670. JSR STROUT
    671. JSR COMPACT
    672. MOV A,# Strophen die gleiche{STRING}
    673. JSR STROUT
    674. JSR LINEBREAK
    675. 113:
    676. JSR COMPACT
    677. MOV A,# Anzahl von Versen haben ?{STRING}
    678. JSR STROUT
    679. JSR GOSUB
    680. JSR 980
    681. 114:
    682. JSR GETSTR
    683. MOV F3${STRING},A
    684. JSR COMPACT
    685. MOV B,#j{STRING}
    686. MOV A,F3${STRING}
    687. CHGCTX #0
    688. JSR SEQ
    689. CMP X,#0{REAL}
    690. JE SKIP22
    691. JSR COMPACT
    692. MOV A,# ja{STRING}
    693. JSR STROUT
    694. JSR LINEBREAK
    695. JMP 122
    696. SKIP22:
    697. 116:
    698. JSR COMPACT
    699. MOV B,#n{STRING}
    700. MOV A,F3${STRING}
    701. CHGCTX #0
    702. JSR SNEQ
    703. CMP X,#0{REAL}
    704. JE SKIP23
    705. JMP 114
    706. SKIP23:
    707. 118:
    708. JSR COMPACT
    709. MOV A,# nein{STRING}
    710. JSR STROUT
    711. JSR LINEBREAK
    712. JSR COMPACT
    713. MOV A,# Wieviel Verse sollen es jeweils sein ?{STRING}
    714. JSR STROUT
    715. JSR LINEBREAK
    716. MOV Y,#1{INTEGER}
    717. MOV X,AZ{REAL}
    718. SUB X,Y
    719. PUSH X
    720. MOV Y,#1{INTEGER}
    721. PUSH Y
    722. MOV Y,#0{INTEGER}
    723. MOV D{REAL},Y
    724. MOV A,(D{REAL})
    725. JSR INITFOR
    726. 120:
    727. MOV Y,#1{INTEGER}
    728. MOV X,D{REAL}
    729. ADD X,Y
    730. JSR REALOUT
    731. MOV A,# {STRING}
    732. JSR STROUT
    733. JSR COMPACT
    734. MOV A,#. Strophe {STRING}
    735. JSR STROUT
    736. JSR GOSUB
    737. JSR 920
    738. MOV Y,D{REAL}
    739. PUSH Y
    740. MOV Y,KK{REAL}
    741. POP X
    742. MOV G,VA%[]{INTEGER}
    743. JSR ARRAYSTORE
    744. MOV A,#0{INTEGER}
    745. JSR NEXT
    746. CMP A,#0{INTEGER}
    747. JE ($JUMP)
    748. JMP 136
    749. 122:
    750. JSR LINEBREAK
    751. JSR COMPACT
    752. MOV A,# Vieviele Verse sollen es sein ?{STRING}
    753. JSR STROUT
    754. JSR GOSUB
    755. JSR 980
    756. JSR GOSUB
    757. JSR 920
    758. MOV Y,KK{REAL}
    759. MOV F1{REAL},Y
    760. 124:
    761. MOV Y,#1{INTEGER}
    762. MOV X,AZ{REAL}
    763. SUB X,Y
    764. PUSH X
    765. MOV Y,#1{INTEGER}
    766. PUSH Y
    767. MOV Y,#0{INTEGER}
    768. MOV A{REAL},Y
    769. MOV A,(A{REAL})
    770. JSR INITFOR
    771. MOV Y,A{REAL}
    772. PUSH Y
    773. MOV Y,F1{REAL}
    774. POP X
    775. MOV G,VA%[]{INTEGER}
    776. JSR ARRAYSTORE
    777. MOV A,#0{INTEGER}
    778. JSR NEXT
    779. CMP A,#0{INTEGER}
    780. JE ($JUMP)
    781. 134:
    782. JSR COMPACT
    783. MOV B,CH${STRING}
    784. MOV A${STRING},B
    785. JSR GOSUB
    786. JSR 900
    787. JSR LINEBREAK
    788. 136:
    789. JSR COMPACT
    790. MOV A,# Wir kommen zum formalen Aufbau der{STRING}
    791. JSR STROUT
    792. JSR LINEBREAK
    793. JSR COMPACT
    794. MOV A,# Strophen und Verse.{STRING}
    795. JSR STROUT
    796. JSR LINEBREAK
    797. 138:
    798. JSR COMPACT
    799. MOV A,# Wollen Sie eigene Satzstrukturen{STRING}
    800. JSR STROUT
    801. JSR LINEBREAK
    802. 140:
    803. JSR COMPACT
    804. MOV A,# eingeben (1) oder bereits gespeicherte{STRING}
    805. JSR STROUT
    806. JSR LINEBREAK
    807. JSR COMPACT
    808. MOV A,# verwenden (2){STRING}
    809. JSR STROUT
    810. 141:
    811. JSR GOSUB
    812. JSR 980
    813. 142:
    814. JSR GETSTR
    815. MOV F1${STRING},A
    816. JSR COMPACT
    817. MOV B,#2{STRING}
    818. MOV A,F1${STRING}
    819. CHGCTX #0
    820. JSR SNEQ
    821. PUSH X
    822. CHGCTX #1
    823. MOV B,#1{STRING}
    824. MOV A,F1${STRING}
    825. CHGCTX #0
    826. JSR SNEQ
    827. POP Y
    828. AND X,Y
    829. CMP X,#0{REAL}
    830. JE SKIP24
    831. JMP 142
    832. SKIP24:
    833. 144:
    834. JSR COMPACT
    835. MOV B,#2{STRING}
    836. MOV A,F1${STRING}
    837. CHGCTX #0
    838. JSR SEQ
    839. CMP X,#0{REAL}
    840. JE SKIP25
    841. JSR COMPACT
    842. MOV A,# gespeicherte{STRING}
    843. JSR STROUT
    844. JSR LINEBREAK
    845. JMP 200
    846. SKIP25:
    847. 146:
    848. JSR COMPACT
    849. MOV A,# selbst eingeben{STRING}
    850. JSR STROUT
    851. JSR LINEBREAK
    852. 180:
    853. JSR COMPACT
    854. MOV Y,#147{INTEGER}
    855. CHGCTX #1
    856. JSR CHR
    857. JSR STROUT
    858. JSR LINEBREAK
    859. JSR COMPACT
    860. MOV A,# 1. Strophe{STRING}
    861. JSR STROUT
    862. JSR LINEBREAK
    863. MOV X,#0{INTEGER}
    864. MOV G,VA%[]{INTEGER}
    865. CHGCTX #0
    866. JSR ARRAYACCESS
    867. PUSH X
    868. MOV Y,#1{INTEGER}
    869. PUSH Y
    870. MOV Y,#1{INTEGER}
    871. MOV A{REAL},Y
    872. MOV A,(A{REAL})
    873. JSR INITFOR
    874. MOV X,A{REAL}
    875. JSR REALOUT
    876. MOV A,# {STRING}
    877. JSR STROUT
    878. JSR COMPACT
    879. MOV A,#. Vers{STRING}
    880. JSR STROUT
    881. 181:
    882. MOV A,#{STRING}
    883. JSR STROUT
    884. INPUT0:
    885. JSR CLEARQUEUE
    886. MOV Y,#1{INTEGER}
    887. MOV X,A{REAL}
    888. SUB X,Y
    889. PUSH X
    890. MOV A,#? {STRING}
    891. JSR STROUT
    892. JSR INPUTSTR
    893. POP X
    894. MOV G,MN$[]{STRING}
    895. JSR ARRAYSTORE
    896. MOV A,#0{INTEGER}
    897. JSR NEXT
    898. CMP A,#0{INTEGER}
    899. JE ($JUMP)
    900. JSR COMPACT
    901. MOV B,#n{STRING}
    902. MOV A,F3${STRING}
    903. CHGCTX #0
    904. JSR SEQ
    905. CMP X,#0{REAL}
    906. JE SKIP26
    907. JSR LINEBREAK
    908. JMP 190
    909. SKIP26:
    910. 182:
    911. MOV Y,#1{INTEGER}
    912. MOV X,AZ{REAL}
    913. EQ X,Y
    914. CMP X,#0{REAL}
    915. JE SKIP27
    916. JMP 196
    917. SKIP27:
    918. 183:
    919. JSR LINEBREAK
    920. JSR COMPACT
    921. MOV A,# Sollen alle restlichen Strophen den{STRING}
    922. JSR STROUT
    923. JSR LINEBREAK
    924. 184:
    925. JSR COMPACT
    926. MOV A,# gleichen Aufbau besitzen {STRING}
    927. JSR STROUT
    928. JSR GOSUB
    929. JSR 980
    930. 185:
    931. JSR GETSTR
    932. MOV F1${STRING},A
    933. JSR COMPACT
    934. MOV B,#j{STRING}
    935. MOV A,F1${STRING}
    936. CHGCTX #0
    937. JSR SEQ
    938. CMP X,#0{REAL}
    939. JE SKIP28
    940. JSR COMPACT
    941. MOV A,# ja{STRING}
    942. JSR STROUT
    943. JSR LINEBREAK
    944. JMP 196
    945. SKIP28:
    946. 186:
    947. JSR COMPACT
    948. MOV B,#n{STRING}
    949. MOV A,F1${STRING}
    950. CHGCTX #0
    951. JSR SNEQ
    952. CMP X,#0{REAL}
    953. JE SKIP29
    954. JMP 185
    955. SKIP29:
    956. 190:
    957. JSR COMPACT
    958. MOV A,# nein{STRING}
    959. JSR STROUT
    960. JSR LINEBREAK
    961. MOV Y,#1{INTEGER}
    962. MOV X,AZ{REAL}
    963. SUB X,Y
    964. PUSH X
    965. MOV Y,#1{INTEGER}
    966. PUSH Y
    967. MOV Y,#1{INTEGER}
    968. MOV A{REAL},Y
    969. MOV A,(A{REAL})
    970. JSR INITFOR
    971. MOV Y,#1{INTEGER}
    972. MOV X,A{REAL}
    973. ADD X,Y
    974. JSR REALOUT
    975. MOV A,# {STRING}
    976. JSR STROUT
    977. JSR COMPACT
    978. MOV A,#. Strophe{STRING}
    979. JSR STROUT
    980. JSR LINEBREAK
    981. MOV X,A{REAL}
    982. MOV G,VA%[]{INTEGER}
    983. CHGCTX #0
    984. JSR ARRAYACCESS
    985. PUSH X
    986. MOV Y,#1{INTEGER}
    987. PUSH Y
    988. MOV Y,#1{INTEGER}
    989. MOV B{REAL},Y
    990. MOV A,(B{REAL})
    991. JSR INITFOR
    992. MOV X,B{REAL}
    993. JSR REALOUT
    994. MOV A,# {STRING}
    995. JSR STROUT
    996. JSR COMPACT
    997. MOV A,#. Vers{STRING}
    998. JSR STROUT
    999. 192:
    1000. MOV A,# {STRING}
    1001. JSR STROUT
    1002. INPUT1:
    1003. JSR CLEARQUEUE
    1004. MOV X,A{REAL}
    1005. MOV G,VA%[]{INTEGER}
    1006. CHGCTX #0
    1007. JSR ARRAYACCESS
    1008. MOV Y,X
    1009. MOV X,A{REAL}
    1010. MUL X,Y
    1011. MOV Y,B{REAL}
    1012. ADD X,Y
    1013. MOV Y,#1{INTEGER}
    1014. SUB X,Y
    1015. PUSH X
    1016. MOV A,#? {STRING}
    1017. JSR STROUT
    1018. JSR INPUTSTR
    1019. POP X
    1020. MOV G,MN$[]{STRING}
    1021. JSR ARRAYSTORE
    1022. MOV A,(B{})
    1023. JSR NEXT
    1024. CMP A,#0{INTEGER}
    1025. JE ($JUMP)
    1026. JSR LINEBREAK
    1027. MOV A,(A{})
    1028. JSR NEXT
    1029. CMP A,#0{INTEGER}
    1030. JE ($JUMP)
    1031. JMP 300
    1032. 196:
    1033. MOV Y,AZ{REAL}
    1034. PUSH Y
    1035. MOV Y,#1{INTEGER}
    1036. PUSH Y
    1037. MOV Y,#1{INTEGER}
    1038. MOV A{REAL},Y
    1039. MOV A,(A{REAL})
    1040. JSR INITFOR
    1041. MOV Y,#1{INTEGER}
    1042. MOV X,#0{INTEGER}
    1043. PUSH Y
    1044. MOV G,VA%[]{INTEGER}
    1045. CHGCTX #0
    1046. JSR ARRAYACCESS
    1047. POP Y
    1048. SUB X,Y
    1049. PUSH X
    1050. MOV Y,#1{INTEGER}
    1051. PUSH Y
    1052. MOV Y,#0{INTEGER}
    1053. MOV B{REAL},Y
    1054. MOV A,(B{REAL})
    1055. JSR INITFOR
    1056. MOV X,A{REAL}
    1057. MOV G,VA%[]{INTEGER}
    1058. CHGCTX #0
    1059. JSR ARRAYACCESS
    1060. MOV Y,X
    1061. MOV X,A{REAL}
    1062. MUL X,Y
    1063. MOV Y,B{REAL}
    1064. ADD X,Y
    1065. PUSH X
    1066. JSR COMPACT
    1067. MOV X,B{REAL}
    1068. CHGCTX #1
    1069. MOV G,MN$[]{STRING}
    1070. JSR ARRAYACCESS
    1071. JSR COPYSTR
    1072. POP X
    1073. MOV G,MN$[]{STRING}
    1074. JSR ARRAYSTORE
    1075. MOV A,(B{})
    1076. JSR NEXT
    1077. CMP A,#0{INTEGER}
    1078. JE ($JUMP)
    1079. MOV A,(A{})
    1080. JSR NEXT
    1081. CMP A,#0{INTEGER}
    1082. JE ($JUMP)
    1083. JMP 300
    1084. 200:
    1085. JSR LINEBREAK
    1086. JSR COMPACT
    1087. MOV A,# Ihr C64 wird Ihnen nun alle in den{STRING}
    1088. JSR STROUT
    1089. JSR LINEBREAK
    1090. 202:
    1091. JSR COMPACT
    1092. MOV A,# DATA-Zeilen gespeicherten Satz-{STRING}
    1093. JSR STROUT
    1094. JSR LINEBREAK
    1095. 204:
    1096. JSR COMPACT
    1097. MOV A,# strukturen auflisten und fragen,{STRING}
    1098. JSR STROUT
    1099. JSR LINEBREAK
    1100. 206:
    1101. JSR COMPACT
    1102. MOV A,# ob Sie sie bei 'Ihrem' Gedicht {STRING}
    1103. JSR STROUT
    1104. JSR LINEBREAK
    1105. 208:
    1106. JSR COMPACT
    1107. MOV A,# vielleicht brauchen koennen.{STRING}
    1108. JSR STROUT
    1109. JSR LINEBREAK
    1110. JSR COMPACT
    1111. MOV A,# Eine erste Auswahl also.{STRING}
    1112. JSR STROUT
    1113. JSR LINEBREAK
    1114. 210:
    1115. JSR COMPACT
    1116. MOV A,# Damit Sie sehen,was sie da so aus-{STRING}
    1117. JSR STROUT
    1118. JSR LINEBREAK
    1119. 212:
    1120. JSR COMPACT
    1121. MOV A,# waehlen,wird Ihnen zu jeder Struktur{STRING}
    1122. JSR STROUT
    1123. JSR LINEBREAK
    1124. 214:
    1125. JSR COMPACT
    1126. MOV A,# ein Satz geliefert,wie er vom Proramm{STRING}
    1127. JSR STROUT
    1128. JSR LINEBREAK
    1129. 216:
    1130. JSR COMPACT
    1131. MOV A,# unter Benutzung eben jener Struktur{STRING}
    1132. JSR STROUT
    1133. JSR LINEBREAK
    1134. 218:
    1135. JSR COMPACT
    1136. MOV A,# produziert werden koennte.{STRING}
    1137. JSR STROUT
    1138. JSR LINEBREAK
    1139. MOV Y,#0{INTEGER}
    1140. MOV ZZ{REAL},Y
    1141. JSR RESTORE
    1142. JSR GOSUB
    1143. JSR 980
    1144. 219:
    1145. MOV Y,#35{INTEGER}
    1146. PUSH Y
    1147. MOV Y,#1{INTEGER}
    1148. PUSH Y
    1149. MOV Y,#1{INTEGER}
    1150. MOV A{REAL},Y
    1151. MOV A,(A{REAL})
    1152. JSR INITFOR
    1153. JSR READSTR
    1154. MOV A${STRING},A
    1155. MOV A,#0{INTEGER}
    1156. JSR NEXT
    1157. CMP A,#0{INTEGER}
    1158. JE ($JUMP)
    1159. 220:
    1160. JSR LINEBREAK
    1161. JSR READSTR
    1162. MOV A${STRING},A
    1163. JSR READSTR
    1164. MOV B${STRING},A
    1165. JSR COMPACT
    1166. MOV B,#@@@{STRING}
    1167. MOV A,A${STRING}
    1168. CHGCTX #0
    1169. JSR SEQ
    1170. CMP X,#0{REAL}
    1171. JE SKIP30
    1172. JMP 230
    1173. SKIP30:
    1174. 221:
    1175. JSR COMPACT
    1176. MOV A,A${STRING}
    1177. JSR STROUT
    1178. JSR LINEBREAK
    1179. JSR COMPACT
    1180. MOV A,B${STRING}
    1181. JSR STROUT
    1182. JSR LINEBREAK
    1183. JSR COMPACT
    1184. MOV Y,#18{INTEGER}
    1185. CHGCTX #1
    1186. JSR CHR
    1187. JSR STROUT
    1188. JSR COMPACT
    1189. MOV A,#j/n{STRING}
    1190. JSR STROUT
    1191. JSR LINEBREAK
    1192. 222:
    1193. JSR GETSTR
    1194. MOV C${STRING},A
    1195. JSR COMPACT
    1196. MOV B,#n{STRING}
    1197. MOV A,C${STRING}
    1198. CHGCTX #0
    1199. JSR SEQ
    1200. CMP X,#0{REAL}
    1201. JE SKIP31
    1202. JMP 220
    1203. SKIP31:
    1204. 224:
    1205. JSR COMPACT
    1206. MOV B,#j{STRING}
    1207. MOV A,C${STRING}
    1208. CHGCTX #0
    1209. JSR SNEQ
    1210. CMP X,#0{REAL}
    1211. JE SKIP32
    1212. JMP 222
    1213. SKIP32:
    1214. 226:
    1215. MOV Y,#21{INTEGER}
    1216. MOV X,#0{INTEGER}
    1217. MUL X,Y
    1218. MOV Y,X
    1219. MOV X,ZZ{REAL}
    1220. ADD X,Y
    1221. PUSH X
    1222. JSR COMPACT
    1223. MOV A,A${STRING}
    1224. POP X
    1225. MOV G,PM$[]{STRING}
    1226. JSR ARRAYSTORE
    1227. MOV Y,#21{INTEGER}
    1228. MOV X,#1{INTEGER}
    1229. MUL X,Y
    1230. MOV Y,X
    1231. MOV X,ZZ{REAL}
    1232. ADD X,Y
    1233. PUSH X
    1234. JSR COMPACT
    1235. MOV A,B${STRING}
    1236. POP X
    1237. MOV G,PM$[]{STRING}
    1238. JSR ARRAYSTORE
    1239. MOV Y,#1{INTEGER}
    1240. MOV X,ZZ{REAL}
    1241. ADD X,Y
    1242. MOV ZZ{REAL},X
    1243. JSR COMPACT
    1244. MOV Y,#21{INTEGER}
    1245. MOV X,#1{INTEGER}
    1246. MUL X,Y
    1247. MOV Y,X
    1248. MOV X,ZZ{REAL}
    1249. ADD X,Y
    1250. CHGCTX #1
    1251. MOV G,PM$[]{STRING}
    1252. JSR ARRAYACCESS
    1253. JSR STROUT
    1254. MOV A,# {STRING}
    1255. JSR STROUT
    1256. MOV X,ZZ{REAL}
    1257. JSR REALOUT
    1258. JSR LINEBREAK
    1259. JMP 220
    1260. 230:
    1261. JSR LINEBREAK
    1262. JSR COMPACT
    1263. MOV A,# Waehlen Sie nun fuer jeden Vers die{STRING}
    1264. JSR STROUT
    1265. JSR LINEBREAK
    1266. 232:
    1267. JSR COMPACT
    1268. MOV A,# gewuenschte Satzstruktur aus.{STRING}
    1269. JSR STROUT
    1270. JSR LINEBREAK
    1271. JSR GOSUB
    1272. JSR 980
    1273. 234:
    1274. JSR GETSTR
    1275. MOV A${STRING},A
    1276. JSR COMPACT
    1277. MOV B,#{STRING}
    1278. MOV A,A${STRING}
    1279. CHGCTX #0
    1280. JSR SEQ
    1281. CMP X,#0{REAL}
    1282. JE SKIP33
    1283. JMP 234
    1284. SKIP33:
    1285. 236:
    1286. JSR COMPACT
    1287. MOV Y,#147{INTEGER}
    1288. CHGCTX #1
    1289. JSR CHR
    1290. JSR STROUT
    1291. JSR LINEBREAK
    1292. JSR LINEBREAK
    1293. MOV Y,#1{INTEGER}
    1294. MOV X,ZZ{REAL}
    1295. SUB X,Y
    1296. PUSH X
    1297. MOV Y,#1{INTEGER}
    1298. PUSH Y
    1299. MOV Y,#0{INTEGER}
    1300. MOV A{REAL},Y
    1301. MOV A,(A{REAL})
    1302. JSR INITFOR
    1303. JSR COMPACT
    1304. MOV Y,#65{INTEGER}
    1305. MOV X,A{REAL}
    1306. ADD X,Y
    1307. MOV Y,X
    1308. CHGCTX #1
    1309. JSR CHR
    1310. JSR STROUT
    1311. JSR COMPACT
    1312. MOV A,#. {STRING}
    1313. JSR STROUT
    1314. JSR COMPACT
    1315. MOV Y,#21{INTEGER}
    1316. MOV X,#1{INTEGER}
    1317. MUL X,Y
    1318. MOV Y,X
    1319. MOV X,A{REAL}
    1320. ADD X,Y
    1321. CHGCTX #1
    1322. MOV G,PM$[]{STRING}
    1323. JSR ARRAYACCESS
    1324. JSR STROUT
    1325. JSR LINEBREAK
    1326. MOV A,#0{INTEGER}
    1327. JSR NEXT
    1328. CMP A,#0{INTEGER}
    1329. JE ($JUMP)
    1330. 238:
    1331. MOV Y,#1{INTEGER}
    1332. MOV X,AZ{REAL}
    1333. SUB X,Y
    1334. PUSH X
    1335. MOV Y,#1{INTEGER}
    1336. PUSH Y
    1337. MOV Y,#0{INTEGER}
    1338. MOV A{REAL},Y
    1339. MOV A,(A{REAL})
    1340. JSR INITFOR
    1341. MOV Y,#1{INTEGER}
    1342. MOV X,A{REAL}
    1343. PUSH Y
    1344. MOV G,VA%[]{INTEGER}
    1345. CHGCTX #0
    1346. JSR ARRAYACCESS
    1347. POP Y
    1348. SUB X,Y
    1349. PUSH X
    1350. MOV Y,#1{INTEGER}
    1351. PUSH Y
    1352. MOV Y,#0{INTEGER}
    1353. MOV B{REAL},Y
    1354. MOV A,(B{REAL})
    1355. JSR INITFOR
    1356. JSR COMPACT
    1357. MOV Y,#19{INTEGER}
    1358. CHGCTX #1
    1359. JSR CHR
    1360. JSR STROUT
    1361. JSR COMPACT
    1362. MOV A,# {STRING}
    1363. JSR STROUT
    1364. JSR LINEBREAK
    1365. 239:
    1366. JSR COMPACT
    1367. MOV Y,#19{INTEGER}
    1368. CHGCTX #1
    1369. JSR CHR
    1370. JSR STROUT
    1371. MOV Y,#1{INTEGER}
    1372. MOV X,A{REAL}
    1373. ADD X,Y
    1374. JSR REALOUT
    1375. MOV A,# {STRING}
    1376. JSR STROUT
    1377. JSR COMPACT
    1378. MOV A,#. Strophe,{STRING}
    1379. JSR STROUT
    1380. MOV Y,#1{INTEGER}
    1381. MOV X,B{REAL}
    1382. ADD X,Y
    1383. JSR REALOUT
    1384. MOV A,# {STRING}
    1385. JSR STROUT
    1386. JSR COMPACT
    1387. MOV A,#. Vers {STRING}
    1388. JSR STROUT
    1389. JSR LINEBREAK
    1390. 240:
    1391. JSR GETSTR
    1392. MOV A${STRING},A
    1393. JSR COMPACT
    1394. MOV B,#{STRING}
    1395. MOV A,A${STRING}
    1396. CHGCTX #0
    1397. JSR SEQ
    1398. CMP X,#0{REAL}
    1399. JE SKIP34
    1400. JMP 240
    1401. SKIP34:
    1402. 241:
    1403. JSR COMPACT
    1404. MOV Y,#64{INTEGER}
    1405. MOV X,ZZ{REAL}
    1406. ADD X,Y
    1407. PUSH X
    1408. CHGCTX #1
    1409. MOV B,A${STRING}
    1410. CHGCTX #0
    1411. JSR ASC
    1412. POP Y
    1413. GT X,Y
    1414. PUSH X
    1415. MOV Y,#65{INTEGER}
    1416. PUSH Y
    1417. CHGCTX #1
    1418. MOV B,A${STRING}
    1419. CHGCTX #0
    1420. JSR ASC
    1421. POP Y
    1422. LT X,Y
    1423. POP Y
    1424. OR X,Y
    1425. CMP X,#0{REAL}
    1426. JE SKIP35
    1427. JMP 240
    1428. SKIP35:
    1429. 242:
    1430. MOV X,A{REAL}
    1431. MOV G,VA%[]{INTEGER}
    1432. CHGCTX #0
    1433. JSR ARRAYACCESS
    1434. MOV Y,X
    1435. MOV X,A{REAL}
    1436. MUL X,Y
    1437. MOV Y,B{REAL}
    1438. ADD X,Y
    1439. PUSH X
    1440. JSR COMPACT
    1441. MOV Y,#21{INTEGER}
    1442. MOV X,#0{INTEGER}
    1443. MUL X,Y
    1444. PUSH X
    1445. MOV Y,#65{INTEGER}
    1446. PUSH Y
    1447. CHGCTX #1
    1448. MOV B,A${STRING}
    1449. CHGCTX #0
    1450. JSR ASC
    1451. POP Y
    1452. SUB X,Y
    1453. POP Y
    1454. ADD X,Y
    1455. CHGCTX #1
    1456. MOV G,PM$[]{STRING}
    1457. JSR ARRAYACCESS
    1458. JSR COPYSTR
    1459. POP X
    1460. MOV G,MN$[]{STRING}
    1461. JSR ARRAYSTORE
    1462. MOV A,(B{})
    1463. JSR NEXT
    1464. CMP A,#0{INTEGER}
    1465. JE ($JUMP)
    1466. MOV A,(A{})
    1467. JSR NEXT
    1468. CMP A,#0{INTEGER}
    1469. JE ($JUMP)
    1470. 300:
    1471. NOP
    1472. 301:
    1473. MOV Y,#53281{INTEGER}
    1474. PUSH Y
    1475. MOV X,#5{INTEGER}
    1476. POP Y
    1477. MOV (Y),X
    1478. MOV Y,#53280{INTEGER}
    1479. PUSH Y
    1480. MOV X,#0{INTEGER}
    1481. POP Y
    1482. MOV (Y),X
    1483. MOV Y,#646{INTEGER}
    1484. PUSH Y
    1485. MOV X,#1{INTEGER}
    1486. POP Y
    1487. MOV (Y),X
    1488. JSR COMPACT
    1489. MOV Y,#147{INTEGER}
    1490. CHGCTX #1
    1491. JSR CHR
    1492. JSR STROUT
    1493. 302:
    1494. MOV Y,#10{INTEGER}
    1495. PUSH Y
    1496. MOV Y,#1{INTEGER}
    1497. PUSH Y
    1498. MOV Y,#1{INTEGER}
    1499. MOV A{REAL},Y
    1500. MOV A,(A{REAL})
    1501. JSR INITFOR
    1502. JSR LINEBREAK
    1503. MOV A,#0{INTEGER}
    1504. JSR NEXT
    1505. CMP A,#0{INTEGER}
    1506. JE ($JUMP)
    1507. JSR COMPACT
    1508. MOV Y,#10{INTEGER}
    1509. CHGCTX #1
    1510. JSR TAB
    1511. JSR STROUT
    1512. 303:
    1513. MOV Y,#19{INTEGER}
    1514. PUSH Y
    1515. MOV Y,#1{INTEGER}
    1516. PUSH Y
    1517. MOV Y,#1{INTEGER}
    1518. MOV A{REAL},Y
    1519. MOV A,(A{REAL})
    1520. JSR INITFOR
    1521. JSR COMPACT
    1522. MOV C,A{REAL}
    1523. MOV D,#1{INTEGER}
    1524. CHGCTX #1
    1525. MOV B,#l'art pour l'art...{STRING}
    1526. JSR MID
    1527. JSR STROUT
    1528. MOV Y,#10{INTEGER}
    1529. PUSH Y
    1530. MOV Y,#1{INTEGER}
    1531. PUSH Y
    1532. MOV Y,#1{INTEGER}
    1533. MOV B{REAL},Y
    1534. MOV A,(B{REAL})
    1535. JSR INITFOR
    1536. 304:
    1537. MOV Y,#24{INTEGER}
    1538. MOV X,S1{REAL}
    1539. ADD X,Y
    1540. PUSH X
    1541. MOV X,#0{INTEGER}
    1542. POP Y
    1543. MOV (Y),X
    1544. MOV Y,#24{INTEGER}
    1545. MOV X,S1{REAL}
    1546. ADD X,Y
    1547. PUSH X
    1548. MOV X,#15{INTEGER}
    1549. POP Y
    1550. MOV (Y),X
    1551. MOV A,(B{})
    1552. JSR NEXT
    1553. CMP A,#0{INTEGER}
    1554. JE ($JUMP)
    1555. MOV A,(A{})
    1556. JSR NEXT
    1557. CMP A,#0{INTEGER}
    1558. JE ($JUMP)
    1559. MOV Y,#1000{INTEGER}
    1560. PUSH Y
    1561. MOV Y,#1{INTEGER}
    1562. PUSH Y
    1563. MOV Y,#1{INTEGER}
    1564. MOV A{REAL},Y
    1565. MOV A,(A{REAL})
    1566. JSR INITFOR
    1567. MOV A,#0{INTEGER}
    1568. JSR NEXT
    1569. CMP A,#0{INTEGER}
    1570. JE ($JUMP)
    1571. JSR COMPACT
    1572. MOV B,#j{STRING}
    1573. MOV A,DR${STRING}
    1574. CHGCTX #0
    1575. JSR SEQ
    1576. CMP X,#0{REAL}
    1577. JE SKIP36
    1578. NOP
    1579. SKIP36:
    1580. 305:
    1581. JSR COMPACT
    1582. MOV Y,#147{INTEGER}
    1583. CHGCTX #1
    1584. JSR CHR
    1585. JSR STROUT
    1586. JSR LINEBREAK
    1587. MOV Y,#1{INTEGER}
    1588. MOV X,AZ{REAL}
    1589. SUB X,Y
    1590. PUSH X
    1591. MOV Y,#1{INTEGER}
    1592. PUSH Y
    1593. MOV Y,#0{INTEGER}
    1594. MOV A{REAL},Y
    1595. MOV A,(A{REAL})
    1596. JSR INITFOR
    1597. MOV Y,#1{INTEGER}
    1598. MOV X,A{REAL}
    1599. PUSH Y
    1600. MOV G,VA%[]{INTEGER}
    1601. CHGCTX #0
    1602. JSR ARRAYACCESS
    1603. POP Y
    1604. SUB X,Y
    1605. PUSH X
    1606. MOV Y,#1{INTEGER}
    1607. PUSH Y
    1608. MOV Y,#0{INTEGER}
    1609. MOV B{REAL},Y
    1610. MOV A,(B{REAL})
    1611. JSR INITFOR
    1612. JSR COMPACT
    1613. MOV X,A{REAL}
    1614. MOV G,VA%[]{INTEGER}
    1615. CHGCTX #0
    1616. JSR ARRAYACCESS
    1617. MOV Y,X
    1618. MOV X,A{REAL}
    1619. MUL X,Y
    1620. MOV Y,B{REAL}
    1621. ADD X,Y
    1622. CHGCTX #1
    1623. MOV G,MN$[]{STRING}
    1624. JSR ARRAYACCESS
    1625. JSR COPYSTR
    1626. MOV W${STRING},A
    1627. MOV Y,#1{INTEGER}
    1628. MOV Z1{REAL},Y
    1629. MOV Y,#0{INTEGER}
    1630. MOV Z2{REAL},Y
    1631. 306:
    1632. JSR COMPACT
    1633. MOV C,Z1{REAL}
    1634. MOV D,#3{INTEGER}
    1635. CHGCTX #1
    1636. MOV B,W${STRING}
    1637. JSR MID
    1638. JSR COPYSTR
    1639. MOV M${STRING},A
    1640. JSR COMPACT
    1641. MOV B,#{STRING}
    1642. MOV A,M${STRING}
    1643. CHGCTX #0
    1644. JSR SEQ
    1645. CMP X,#0{REAL}
    1646. JE SKIP37
    1647. JMP 712
    1648. SKIP37:
    1649. 307:
    1650. NOP
    1651. 308:
    1652. JSR COMPACT
    1653. MOV B,#und{STRING}
    1654. MOV A,M${STRING}
    1655. CHGCTX #0
    1656. JSR SEQ
    1657. CMP X,#0{REAL}
    1658. JE SKIP38
    1659. MOV Y,Z2{REAL}
    1660. PUSH Y
    1661. JSR COMPACT
    1662. MOV A,M${STRING}
    1663. POP X
    1664. MOV G,E$[]{STRING}
    1665. JSR ARRAYSTORE
    1666. MOV Y,#4{INTEGER}
    1667. MOV X,Z1{REAL}
    1668. ADD X,Y
    1669. MOV Z1{REAL},X
    1670. JMP 710
    1671. SKIP38:
    1672. 309:
    1673. NOP
    1674. 310:
    1675. JSR COMPACT
    1676. MOV B,#odr{STRING}
    1677. MOV A,M${STRING}
    1678. CHGCTX #0
    1679. JSR SEQ
    1680. CMP X,#0{REAL}
    1681. JE SKIP39
    1682. MOV Y,Z2{REAL}
    1683. PUSH Y
    1684. JSR COMPACT
    1685. MOV A,#oder{STRING}
    1686. POP X
    1687. MOV G,E$[]{STRING}
    1688. JSR ARRAYSTORE
    1689. MOV Y,#4{INTEGER}
    1690. MOV X,Z1{REAL}
    1691. ADD X,Y
    1692. MOV Z1{REAL},X
    1693. JMP 710
    1694. SKIP39:
    1695. 311:
    1696. NOP
    1697. 312:
    1698. JSR COMPACT
    1699. MOV B,#pra{STRING}
    1700. MOV A,M${STRING}
    1701. CHGCTX #0
    1702. JSR SEQ
    1703. CMP X,#0{REAL}
    1704. JE SKIP40
    1705. MOV Y,Z2{REAL}
    1706. PUSH Y
    1707. JSR COMPACT
    1708. MOV Y,Q1{REAL}
    1709. PUSH Y
    1710. MOV Y,#1{INTEGER}
    1711. RND X,Y
    1712. POP Y
    1713. MUL X,Y
    1714. CHGCTX #1
    1715. MOV G,PR$[]{STRING}
    1716. JSR ARRAYACCESS
    1717. JSR COPYSTR
    1718. POP X
    1719. MOV G,E$[]{STRING}
    1720. JSR ARRAYSTORE
    1721. MOV Y,#4{INTEGER}
    1722. MOV X,Z1{REAL}
    1723. ADD X,Y
    1724. MOV Z1{REAL},X
    1725. JMP 710
    1726. SKIP40:
    1727. 313:
    1728. NOP
    1729. 314:
    1730. JSR COMPACT
    1731. MOV B,#kon{STRING}
    1732. MOV A,M${STRING}
    1733. CHGCTX #0
    1734. JSR SEQ
    1735. CMP X,#0{REAL}
    1736. JE SKIP41
    1737. MOV Y,Z2{REAL}
    1738. PUSH Y
    1739. JSR COMPACT
    1740. MOV Y,Q3{REAL}
    1741. PUSH Y
    1742. MOV Y,#1{INTEGER}
    1743. RND X,Y
    1744. POP Y
    1745. MUL X,Y
    1746. CHGCTX #1
    1747. MOV G,KO$[]{STRING}
    1748. JSR ARRAYACCESS
    1749. JSR COPYSTR
    1750. POP X
    1751. MOV G,E$[]{STRING}
    1752. JSR ARRAYSTORE
    1753. MOV Y,#4{INTEGER}
    1754. MOV X,Z1{REAL}
    1755. ADD X,Y
    1756. MOV Z1{REAL},X
    1757. JMP 710
    1758. SKIP41:
    1759. 315:
    1760. NOP
    1761. 316:
    1762. JSR COMPACT
    1763. MOV B,#tmp{STRING}
    1764. MOV A,M${STRING}
    1765. CHGCTX #0
    1766. JSR SNEQ
    1767. CMP X,#0{REAL}
    1768. JE SKIP42
    1769. JMP 320
    1770. SKIP42:
    1771. 318:
    1772. MOV Y,Z2{REAL}
    1773. PUSH Y
    1774. JSR COMPACT
    1775. MOV Y,Q2{REAL}
    1776. PUSH Y
    1777. MOV Y,#1{INTEGER}
    1778. RND X,Y
    1779. POP Y
    1780. MUL X,Y
    1781. CHGCTX #1
    1782. MOV G,ZE$[]{STRING}
    1783. JSR ARRAYACCESS
    1784. JSR COPYSTR
    1785. POP X
    1786. MOV G,E$[]{STRING}
    1787. JSR ARRAYSTORE
    1788. MOV Y,#4{INTEGER}
    1789. MOV X,Z1{REAL}
    1790. ADD X,Y
    1791. MOV Z1{REAL},X
    1792. JMP 710
    1793. 319:
    1794. NOP
    1795. 320:
    1796. JSR COMPACT
    1797. MOV B,#sub{STRING}
    1798. MOV A,M${STRING}
    1799. CHGCTX #0
    1800. JSR SNEQ
    1801. CMP X,#0{REAL}
    1802. JE SKIP43
    1803. JMP 410
    1804. SKIP43:
    1805. 322:
    1806. JSR COMPACT
    1807. MOV Y,#3{INTEGER}
    1808. MOV X,Z1{REAL}
    1809. ADD X,Y
    1810. MOV C,X
    1811. MOV D,#1{INTEGER}
    1812. CHGCTX #1
    1813. MOV B,W${STRING}
    1814. JSR MID
    1815. MOV B,A
    1816. CHGCTX #0
    1817. JSR VAL
    1818. MOV EA{REAL},X
    1819. JSR COMPACT
    1820. MOV Y,#4{INTEGER}
    1821. MOV X,Z1{REAL}
    1822. ADD X,Y
    1823. MOV C,X
    1824. MOV D,#1{INTEGER}
    1825. CHGCTX #1
    1826. MOV B,W${STRING}
    1827. JSR MID
    1828. MOV B,A
    1829. CHGCTX #0
    1830. JSR VAL
    1831. MOV ED{REAL},X
    1832. JSR COMPACT
    1833. MOV Y,#5{INTEGER}
    1834. MOV X,Z1{REAL}
    1835. ADD X,Y
    1836. MOV C,X
    1837. MOV D,#1{INTEGER}
    1838. CHGCTX #1
    1839. MOV B,W${STRING}
    1840. JSR MID
    1841. MOV B,A
    1842. CHGCTX #0
    1843. JSR VAL
    1844. MOV EF{REAL},X
    1845. 324:
    1846. JSR COMPACT
    1847. MOV Y,#6{INTEGER}
    1848. MOV X,Z1{REAL}
    1849. ADD X,Y
    1850. MOV C,X
    1851. MOV D,#1{INTEGER}
    1852. CHGCTX #1
    1853. MOV B,W${STRING}
    1854. JSR MID
    1855. MOV B,A
    1856. CHGCTX #0
    1857. JSR VAL
    1858. MOV EP{REAL},X
    1859. 326:
    1860. MOV Y,#1{INTEGER}
    1861. MOV X,EA{REAL}
    1862. EQ X,Y
    1863. PUSH X
    1864. MOV Y,#2{INTEGER}
    1865. MOV X,EP{REAL}
    1866. EQ X,Y
    1867. POP Y
    1868. AND X,Y
    1869. CMP X,#0{REAL}
    1870. JE SKIP44
    1871. MOV Y,#2{INTEGER}
    1872. MOV EA{REAL},Y
    1873. SKIP44:
    1874. 328:
    1875. MOV Y,Q4{REAL}
    1876. PUSH Y
    1877. MOV Y,#1{INTEGER}
    1878. RND X,Y
    1879. POP Y
    1880. MUL X,Y
    1881. MOV Y,X
    1882. INT X,Y
    1883. MOV WA{REAL},X
    1884. JSR COMPACT
    1885. MOV Y,#138{INTEGER}
    1886. MOV X,#3{INTEGER}
    1887. MUL X,Y
    1888. MOV Y,X
    1889. MOV X,WA{REAL}
    1890. ADD X,Y
    1891. CHGCTX #1
    1892. MOV G,NO$[]{STRING}
    1893. JSR ARRAYACCESS
    1894. MOV B,A
    1895. CHGCTX #0
    1896. JSR VAL
    1897. MOV Y,#1{INTEGER}
    1898. SUB X,Y
    1899. MOV GE{REAL},X
    1900. 329:
    1901. MOV Y,#-1.0{REAL}
    1902. MOV X,GE{REAL}
    1903. EQ X,Y
    1904. CMP X,#0{REAL}
    1905. JE SKIP45
    1906. MOV Y,#0{INTEGER}
    1907. MOV EA{REAL},Y
    1908. MOV Y,#0{INTEGER}
    1909. MOV GE{REAL},Y
    1910. MOV Y,#0{INTEGER}
    1911. MOV ED{REAL},Y
    1912. MOV Y,#1{INTEGER}
    1913. MOV F%{INTEGER},Y
    1914. JMP 370
    1915. SKIP45:
    1916. 330:
    1917. MOV Y,#0{INTEGER}
    1918. MOV F%{INTEGER},Y
    1919. MOV Y,#2{INTEGER}
    1920. MOV X,EA{REAL}
    1921. LT X,Y
    1922. CMP X,#0{REAL}
    1923. JE SKIP46
    1924. JMP 340
    1925. SKIP46:
    1926. 331:
    1927. MOV Y,#1{INTEGER}
    1928. MOV X,EP{REAL}
    1929. EQ X,Y
    1930. CMP X,#0{REAL}
    1931. JE SKIP47
    1932. MOV Y,Z2{REAL}
    1933. PUSH Y
    1934. JSR COMPACT
    1935. MOV Y,#3{INTEGER}
    1936. MOV X,EF{REAL}
    1937. MUL X,Y
    1938. MOV Y,GE{REAL}
    1939. ADD X,Y
    1940. CHGCTX #1
    1941. MOV G,AR$[]{STRING}
    1942. JSR ARRAYACCESS
    1943. JSR COPYSTR
    1944. POP X
    1945. MOV G,E$[]{STRING}
    1946. JSR ARRAYSTORE
    1947. SKIP47:
    1948. 332:
    1949. MOV Y,#2{INTEGER}
    1950. MOV X,EP{REAL}
    1951. EQ X,Y
    1952. CMP X,#0{REAL}
    1953. JE SKIP48
    1954. MOV Y,Z2{REAL}
    1955. PUSH Y
    1956. JSR COMPACT
    1957. MOV Y,#12{INTEGER}
    1958. MOV X,EF{REAL}
    1959. ADD X,Y
    1960. CHGCTX #1
    1961. MOV G,AR$[]{STRING}
    1962. JSR ARRAYACCESS
    1963. JSR COPYSTR
    1964. POP X
    1965. MOV G,E$[]{STRING}
    1966. JSR ARRAYSTORE
    1967. SKIP48:
    1968. 334:
    1969. MOV Y,#1{INTEGER}
    1970. MOV X,Z2{REAL}
    1971. ADD X,Y
    1972. MOV Z2{REAL},X
    1973. JMP 350
    1974. 340:
    1975. MOV Y,#1{INTEGER}
    1976. MOV X,EA{REAL}
    1977. EQ X,Y
    1978. CMP X,#0{REAL}
    1979. JE SKIP49
    1980. MOV Y,Z2{REAL}
    1981. PUSH Y
    1982. JSR COMPACT
    1983. MOV Y,#3{INTEGER}
    1984. MOV X,EF{REAL}
    1985. MUL X,Y
    1986. MOV Y,GE{REAL}
    1987. ADD X,Y
    1988. CHGCTX #1
    1989. MOV G,EN$[]{STRING}
    1990. JSR ARRAYACCESS
    1991. MOV B,A
    1992. MOV A,#ein{STRING}
    1993. JSR CONCAT
    1994. JSR COPYSTR
    1995. POP X
    1996. MOV G,E$[]{STRING}
    1997. JSR ARRAYSTORE
    1998. MOV Y,#1{INTEGER}
    1999. MOV X,Z2{REAL}
    2000. ADD X,Y
    2001. MOV Z2{REAL},X
    2002. SKIP49:
    2003. 350:
    2004. MOV Y,#0{INTEGER}
    2005. MOV X,ED{REAL}
    2006. EQ X,Y
    2007. CMP X,#0{REAL}
    2008. JE SKIP50
    2009. JMP 370
    2010. SKIP50:
    2011. 351:
    2012. MOV Y,#2{INTEGER}
    2013. MOV X,EP{REAL}
    2014. EQ X,Y
    2015. CMP X,#0{REAL}
    2016. JE SKIP51
    2017. JMP 362
    2018. SKIP51:
    2019. 352:
    2020. MOV Y,Z2{REAL}
    2021. PUSH Y
    2022. JSR COMPACT
    2023. MOV Y,#138{INTEGER}
    2024. MOV X,#2{INTEGER}
    2025. MUL X,Y
    2026. PUSH X
    2027. MOV Y,Q4{REAL}
    2028. PUSH Y
    2029. MOV Y,#1{INTEGER}
    2030. RND X,Y
    2031. POP Y
    2032. MUL X,Y
    2033. POP Y
    2034. ADD X,Y
    2035. CHGCTX #1
    2036. MOV G,NO$[]{STRING}
    2037. JSR ARRAYACCESS
    2038. JSR COPYSTR
    2039. POP X
    2040. MOV G,E$[]{STRING}
    2041. JSR ARRAYSTORE
    2042. MOV Y,#0{INTEGER}
    2043. MOV X,EA{REAL}
    2044. EQ X,Y
    2045. CMP X,#0{REAL}
    2046. JE SKIP52
    2047. MOV Y,Z2{REAL}
    2048. PUSH Y
    2049. JSR COMPACT
    2050. MOV Y,#3{INTEGER}
    2051. MOV X,EF{REAL}
    2052. MUL X,Y
    2053. MOV Y,GE{REAL}
    2054. ADD X,Y
    2055. CHGCTX #1
    2056. MOV G,D3$[]{STRING}
    2057. JSR ARRAYACCESS
    2058. PUSH A
    2059. CHGCTX #0
    2060. MOV X,Z2{REAL}
    2061. CHGCTX #1
    2062. MOV G,E$[]{STRING}
    2063. JSR ARRAYACCESS
    2064. POP B
    2065. JSR CONCAT
    2066. JSR COPYSTR
    2067. POP X
    2068. MOV G,E$[]{STRING}
    2069. JSR ARRAYSTORE
    2070. SKIP52:
    2071. 354:
    2072. MOV Y,#1{INTEGER}
    2073. MOV X,EA{REAL}
    2074. EQ X,Y
    2075. CMP X,#0{REAL}
    2076. JE SKIP53
    2077. MOV Y,Z2{REAL}
    2078. PUSH Y
    2079. JSR COMPACT
    2080. MOV Y,#3{INTEGER}
    2081. MOV X,EF{REAL}
    2082. MUL X,Y
    2083. MOV Y,GE{REAL}
    2084. ADD X,Y
    2085. CHGCTX #1
    2086. MOV G,D2$[]{STRING}
    2087. JSR ARRAYACCESS
    2088. PUSH A
    2089. CHGCTX #0
    2090. MOV X,Z2{REAL}
    2091. CHGCTX #1
    2092. MOV G,E$[]{STRING}
    2093. JSR ARRAYACCESS
    2094. POP B
    2095. JSR CONCAT
    2096. JSR COPYSTR
    2097. POP X
    2098. MOV G,E$[]{STRING}
    2099. JSR ARRAYSTORE
    2100. SKIP53:
    2101. 356:
    2102. MOV Y,#2{INTEGER}
    2103. MOV X,EA{REAL}
    2104. EQ X,Y
    2105. CMP X,#0{REAL}
    2106. JE SKIP54
    2107. MOV Y,Z2{REAL}
    2108. PUSH Y
    2109. JSR COMPACT
    2110. MOV Y,#3{INTEGER}
    2111. MOV X,EF{REAL}
    2112. MUL X,Y
    2113. MOV Y,GE{REAL}
    2114. ADD X,Y
    2115. CHGCTX #1
    2116. MOV G,D4$[]{STRING}
    2117. JSR ARRAYACCESS
    2118. PUSH A
    2119. CHGCTX #0
    2120. MOV X,Z2{REAL}
    2121. CHGCTX #1
    2122. MOV G,E$[]{STRING}
    2123. JSR ARRAYACCESS
    2124. POP B
    2125. JSR CONCAT
    2126. JSR COPYSTR
    2127. POP X
    2128. MOV G,E$[]{STRING}
    2129. JSR ARRAYSTORE
    2130. SKIP54:
    2131. 360:
    2132. MOV Y,#1{INTEGER}
    2133. MOV X,Z2{REAL}
    2134. ADD X,Y
    2135. MOV Z2{REAL},X
    2136. JMP 370
    2137. 362:
    2138. MOV Y,Z2{REAL}
    2139. PUSH Y
    2140. JSR COMPACT
    2141. MOV Y,#138{INTEGER}
    2142. MOV X,#2{INTEGER}
    2143. MUL X,Y
    2144. PUSH X
    2145. MOV Y,Q4{REAL}
    2146. PUSH Y
    2147. MOV Y,#1{INTEGER}
    2148. RND X,Y
    2149. POP Y
    2150. MUL X,Y
    2151. POP Y
    2152. ADD X,Y
    2153. CHGCTX #1
    2154. MOV G,NO$[]{STRING}
    2155. JSR ARRAYACCESS
    2156. JSR COPYSTR
    2157. POP X
    2158. MOV G,E$[]{STRING}
    2159. JSR ARRAYSTORE
    2160. MOV Y,#0{INTEGER}
    2161. MOV X,EA{REAL}
    2162. EQ X,Y
    2163. CMP X,#0{REAL}
    2164. JE SKIP55
    2165. MOV Y,Z2{REAL}
    2166. PUSH Y
    2167. JSR COMPACT
    2168. MOV Y,#12{INTEGER}
    2169. MOV X,EF{REAL}
    2170. ADD X,Y
    2171. CHGCTX #1
    2172. MOV G,D3$[]{STRING}
    2173. JSR ARRAYACCESS
    2174. PUSH A
    2175. CHGCTX #0
    2176. MOV X,Z2{REAL}
    2177. CHGCTX #1
    2178. MOV G,E$[]{STRING}
    2179. JSR ARRAYACCESS
    2180. POP B
    2181. JSR CONCAT
    2182. JSR COPYSTR
    2183. POP X
    2184. MOV G,E$[]{STRING}
    2185. JSR ARRAYSTORE
    2186. SKIP55:
    2187. 364:
    2188. MOV Y,#2{INTEGER}
    2189. MOV X,EA{REAL}
    2190. EQ X,Y
    2191. CMP X,#0{REAL}
    2192. JE SKIP56
    2193. MOV Y,Z2{REAL}
    2194. PUSH Y
    2195. JSR COMPACT
    2196. MOV Y,#12{INTEGER}
    2197. MOV X,EF{REAL}
    2198. ADD X,Y
    2199. CHGCTX #1
    2200. MOV G,D4$[]{STRING}
    2201. JSR ARRAYACCESS
    2202. PUSH A
    2203. CHGCTX #0
    2204. MOV X,Z2{REAL}
    2205. CHGCTX #1
    2206. MOV G,E$[]{STRING}
    2207. JSR ARRAYACCESS
    2208. POP B
    2209. JSR CONCAT
    2210. JSR COPYSTR
    2211. POP X
    2212. MOV G,E$[]{STRING}
    2213. JSR ARRAYSTORE
    2214. SKIP56:
    2215. 366:
    2216. MOV Y,#1{INTEGER}
    2217. MOV X,Z2{REAL}
    2218. ADD X,Y
    2219. MOV Z2{REAL},X
    2220. NOP
    2221. 370:
    2222. MOV Y,Z2{REAL}
    2223. PUSH Y
    2224. JSR COMPACT
    2225. MOV Y,#1{INTEGER}
    2226. MOV X,EP{REAL}
    2227. SUB X,Y
    2228. MOV Y,#138{INTEGER}
    2229. MUL X,Y
    2230. MOV Y,X
    2231. MOV X,WA{REAL}
    2232. ADD X,Y
    2233. CHGCTX #1
    2234. MOV G,NO$[]{STRING}
    2235. JSR ARRAYACCESS
    2236. JSR COPYSTR
    2237. POP X
    2238. MOV G,E$[]{STRING}
    2239. JSR ARRAYSTORE
    2240. JSR COMPACT
    2241. MOV C,#1{INTEGER}
    2242. MOV X,Z2{REAL}
    2243. CHGCTX #1
    2244. MOV G,E$[]{STRING}
    2245. JSR ARRAYACCESS
    2246. MOV B,A
    2247. JSR RIGHT
    2248. JSR COPYSTR
    2249. MOV L0${STRING},A
    2250. JSR COMPACT
    2251. MOV Y,#1{INTEGER}
    2252. MOV X,Z2{REAL}
    2253. PUSH Y
    2254. CHGCTX #1
    2255. MOV G,E$[]{STRING}
    2256. JSR ARRAYACCESS
    2257. MOV B,A
    2258. CHGCTX #0
    2259. JSR LEN
    2260. POP Y
    2261. SUB X,Y
    2262. MOV C,X
    2263. MOV D,#1{INTEGER}
    2264. MOV X,Z2{REAL}
    2265. CHGCTX #1
    2266. MOV G,E$[]{STRING}
    2267. JSR ARRAYACCESS
    2268. MOV B,A
    2269. JSR MID
    2270. JSR COPYSTR
    2271. MOV L1${STRING},A
    2272. 371:
    2273. JSR COMPACT
    2274. MOV Y,#2{INTEGER}
    2275. MOV X,Z2{REAL}
    2276. PUSH Y
    2277. CHGCTX #1
    2278. MOV G,E$[]{STRING}
    2279. JSR ARRAYACCESS
    2280. MOV B,A
    2281. CHGCTX #0
    2282. JSR LEN
    2283. POP Y
    2284. SUB X,Y
    2285. MOV C,X
    2286. MOV D,#1{INTEGER}
    2287. MOV X,Z2{REAL}
    2288. CHGCTX #1
    2289. MOV G,E$[]{STRING}
    2290. JSR ARRAYACCESS
    2291. MOV B,A
    2292. JSR MID
    2293. JSR COPYSTR
    2294. MOV LZ${STRING},A
    2295. 372:
    2296. MOV Y,#0{INTEGER}
    2297. MOV VO{REAL},Y
    2298. JSR COMPACT
    2299. MOV B,#u{STRING}
    2300. MOV A,L0${STRING}
    2301. CHGCTX #0
    2302. JSR SEQ
    2303. PUSH X
    2304. CHGCTX #1
    2305. MOV B,#o{STRING}
    2306. MOV A,L0${STRING}
    2307. CHGCTX #0
    2308. JSR SEQ
    2309. PUSH X
    2310. CHGCTX #1
    2311. MOV B,#i{STRING}
    2312. MOV A,L0${STRING}
    2313. CHGCTX #0
    2314. JSR SEQ
    2315. PUSH X
    2316. CHGCTX #1
    2317. MOV B,#e{STRING}
    2318. MOV A,L0${STRING}
    2319. CHGCTX #0
    2320. JSR SEQ
    2321. PUSH X
    2322. CHGCTX #1
    2323. MOV B,#a{STRING}
    2324. MOV A,L0${STRING}
    2325. CHGCTX #0
    2326. JSR SEQ
    2327. POP Y
    2328. OR X,Y
    2329. POP Y
    2330. OR X,Y
    2331. POP Y
    2332. OR X,Y
    2333. POP Y
    2334. OR X,Y
    2335. CMP X,#0{REAL}
    2336. JE SKIP57
    2337. MOV Y,#100{INTEGER}
    2338. MOV VO{REAL},Y
    2339. SKIP57:
    2340. 374:
    2341. JSR COMPACT
    2342. MOV B,#u{STRING}
    2343. MOV A,L1${STRING}
    2344. CHGCTX #0
    2345. JSR SEQ
    2346. PUSH X
    2347. CHGCTX #1
    2348. MOV B,#o{STRING}
    2349. MOV A,L1${STRING}
    2350. CHGCTX #0
    2351. JSR SEQ
    2352. PUSH X
    2353. CHGCTX #1
    2354. MOV B,#i{STRING}
    2355. MOV A,L1${STRING}
    2356. CHGCTX #0
    2357. JSR SEQ
    2358. PUSH X
    2359. CHGCTX #1
    2360. MOV B,#e{STRING}
    2361. MOV A,L1${STRING}
    2362. CHGCTX #0
    2363. JSR SEQ
    2364. PUSH X
    2365. CHGCTX #1
    2366. MOV B,#a{STRING}
    2367. MOV A,L1${STRING}
    2368. CHGCTX #0
    2369. JSR SEQ
    2370. POP Y
    2371. OR X,Y
    2372. POP Y
    2373. OR X,Y
    2374. POP Y
    2375. OR X,Y
    2376. POP Y
    2377. OR X,Y
    2378. CMP X,#0{REAL}
    2379. JE SKIP58
    2380. MOV Y,#10{INTEGER}
    2381. MOV X,VO{REAL}
    2382. ADD X,Y
    2383. MOV VO{REAL},X
    2384. SKIP58:
    2385. 375:
    2386. JSR COMPACT
    2387. MOV B,#u{STRING}
    2388. MOV A,LZ${STRING}
    2389. CHGCTX #0
    2390. JSR SEQ
    2391. PUSH X
    2392. CHGCTX #1
    2393. MOV B,#o{STRING}
    2394. MOV A,LZ${STRING}
    2395. CHGCTX #0
    2396. JSR SEQ
    2397. PUSH X
    2398. CHGCTX #1
    2399. MOV B,#i{STRING}
    2400. MOV A,LZ${STRING}
    2401. CHGCTX #0
    2402. JSR SEQ
    2403. PUSH X
    2404. CHGCTX #1
    2405. MOV B,#e{STRING}
    2406. MOV A,LZ${STRING}
    2407. CHGCTX #0
    2408. JSR SEQ
    2409. PUSH X
    2410. CHGCTX #1
    2411. MOV B,#a{STRING}
    2412. MOV A,LZ${STRING}
    2413. CHGCTX #0
    2414. JSR SEQ
    2415. POP Y
    2416. OR X,Y
    2417. POP Y
    2418. OR X,Y
    2419. POP Y
    2420. OR X,Y
    2421. POP Y
    2422. OR X,Y
    2423. CMP X,#0{REAL}
    2424. JE SKIP59
    2425. MOV Y,#1{INTEGER}
    2426. MOV X,VO{REAL}
    2427. ADD X,Y
    2428. MOV VO{REAL},X
    2429. SKIP59:
    2430. 376:
    2431. JSR COMPACT
    2432. MOV B,L1${STRING}
    2433. MOV A,L0${STRING}
    2434. JSR CONCAT
    2435. JSR COPYSTR
    2436. MOV L2${STRING},A
    2437. JSR COMPACT
    2438. MOV C,#3{INTEGER}
    2439. MOV X,Z2{REAL}
    2440. CHGCTX #1
    2441. MOV G,E$[]{STRING}
    2442. JSR ARRAYACCESS
    2443. MOV B,A
    2444. JSR RIGHT
    2445. JSR COPYSTR
    2446. MOV L3${STRING},A
    2447. 378:
    2448. JSR GOSUB
    2449. JSR 930
    2450. MOV Y,Z2{REAL}
    2451. PUSH Y
    2452. JSR COMPACT
    2453. MOV B,AD${STRING}
    2454. CHGCTX #0
    2455. PUSH B
    2456. MOV X,Z2{REAL}
    2457. CHGCTX #1
    2458. MOV G,E$[]{STRING}
    2459. JSR ARRAYACCESS
    2460. POP B
    2461. JSR CONCAT
    2462. JSR COPYSTR
    2463. POP X
    2464. MOV G,E$[]{STRING}
    2465. JSR ARRAYSTORE
    2466. MOV Y,#8{INTEGER}
    2467. MOV X,Z1{REAL}
    2468. ADD X,Y
    2469. MOV Z1{REAL},X
    2470. JMP 710
    2471. 410:
    2472. NOP
    2473. 412:
    2474. JSR COMPACT
    2475. MOV B,#vrb{STRING}
    2476. MOV A,M${STRING}
    2477. CHGCTX #0
    2478. JSR SNEQ
    2479. CMP X,#0{REAL}
    2480. JE SKIP60
    2481. JMP 430
    2482. SKIP60:
    2483. 414:
    2484. JSR COMPACT
    2485. MOV Y,#3{INTEGER}
    2486. MOV X,Z1{REAL}
    2487. ADD X,Y
    2488. MOV C,X
    2489. MOV D,#1{INTEGER}
    2490. CHGCTX #1
    2491. MOV B,W${STRING}
    2492. JSR MID
    2493. MOV B,A
    2494. CHGCTX #0
    2495. JSR VAL
    2496. MOV ET{REAL},X
    2497. JSR COMPACT
    2498. MOV Y,#4{INTEGER}
    2499. MOV X,Z1{REAL}
    2500. ADD X,Y
    2501. MOV C,X
    2502. MOV D,#1{INTEGER}
    2503. CHGCTX #1
    2504. MOV B,W${STRING}
    2505. JSR MID
    2506. MOV B,A
    2507. CHGCTX #0
    2508. JSR VAL
    2509. MOV EP{REAL},X
    2510. 416:
    2511. MOV Y,Q5{REAL}
    2512. PUSH Y
    2513. MOV Y,#1{INTEGER}
    2514. RND X,Y
    2515. POP Y
    2516. MUL X,Y
    2517. MOV WA{REAL},X
    2518. JSR COMPACT
    2519. MOV Y,#90{INTEGER}
    2520. MOV X,#2{INTEGER}
    2521. MUL X,Y
    2522. MOV Y,X
    2523. MOV X,WA{REAL}
    2524. ADD X,Y
    2525. CHGCTX #1
    2526. MOV G,VB$[]{STRING}
    2527. JSR ARRAYACCESS
    2528. MOV B,A
    2529. CHGCTX #0
    2530. JSR VAL
    2531. MOV Y,#2{INTEGER}
    2532. NEQ X,Y
    2533. PUSH X
    2534. MOV Y,#90{INTEGER}
    2535. MOV X,#2{INTEGER}
    2536. MUL X,Y
    2537. MOV Y,X
    2538. MOV X,WA{REAL}
    2539. ADD X,Y
    2540. CHGCTX #1
    2541. MOV G,VB$[]{STRING}
    2542. JSR ARRAYACCESS
    2543. MOV B,A
    2544. CHGCTX #0
    2545. JSR VAL
    2546. MOV Y,ET{REAL}
    2547. NEQ X,Y
    2548. POP Y
    2549. AND X,Y
    2550. CMP X,#0{REAL}
    2551. JE SKIP61
    2552. JMP 416
    2553. SKIP61:
    2554. 418:
    2555. MOV Y,Z2{REAL}
    2556. PUSH Y
    2557. JSR COMPACT
    2558. MOV Y,#1{INTEGER}
    2559. MOV X,EP{REAL}
    2560. SUB X,Y
    2561. MOV Y,#90{INTEGER}
    2562. MUL X,Y
    2563. MOV Y,X
    2564. MOV X,WA{REAL}
    2565. ADD X,Y
    2566. CHGCTX #1
    2567. MOV G,VB$[]{STRING}
    2568. JSR ARRAYACCESS
    2569. JSR COPYSTR
    2570. POP X
    2571. MOV G,E$[]{STRING}
    2572. JSR ARRAYSTORE
    2573. MOV Y,#6{INTEGER}
    2574. MOV X,Z1{REAL}
    2575. ADD X,Y
    2576. MOV Z1{REAL},X
    2577. JMP 710
    2578. 430:
    2579. NOP
    2580. 432:
    2581. JSR COMPACT
    2582. MOV B,#iwo{STRING}
    2583. MOV A,M${STRING}
    2584. CHGCTX #0
    2585. JSR SNEQ
    2586. CMP X,#0{REAL}
    2587. JE SKIP62
    2588. JMP 440
    2589. SKIP62:
    2590. 434:
    2591. MOV Y,Z2{REAL}
    2592. PUSH Y
    2593. JSR COMPACT
    2594. MOV Y,Q6{REAL}
    2595. PUSH Y
    2596. MOV Y,#1{INTEGER}
    2597. RND X,Y
    2598. POP Y
    2599. MUL X,Y
    2600. CHGCTX #1
    2601. MOV G,IW$[]{STRING}
    2602. JSR ARRAYACCESS
    2603. JSR COPYSTR
    2604. POP X
    2605. MOV G,E$[]{STRING}
    2606. JSR ARRAYSTORE
    2607. MOV Y,#4{INTEGER}
    2608. MOV X,Z1{REAL}
    2609. ADD X,Y
    2610. MOV Z1{REAL},X
    2611. JMP 710
    2612. 440:
    2613. NOP
    2614. 442:
    2615. JSR COMPACT
    2616. MOV B,#die{STRING}
    2617. MOV A,M${STRING}
    2618. CHGCTX #0
    2619. JSR SEQ
    2620. CMP X,#0{REAL}
    2621. JE SKIP63
    2622. MOV Y,Z2{REAL}
    2623. PUSH Y
    2624. JSR COMPACT
    2625. MOV A,#die{STRING}
    2626. POP X
    2627. MOV G,E$[]{STRING}
    2628. JSR ARRAYSTORE
    2629. MOV Y,#4{INTEGER}
    2630. MOV X,Z1{REAL}
    2631. ADD X,Y
    2632. MOV Z1{REAL},X
    2633. JMP 710
    2634. SKIP63:
    2635. 444:
    2636. NOP
    2637. 446:
    2638. JSR COMPACT
    2639. MOV B,#kom{STRING}
    2640. MOV A,M${STRING}
    2641. CHGCTX #0
    2642. JSR SEQ
    2643. CMP X,#0{REAL}
    2644. JE SKIP64
    2645. MOV Y,Z2{REAL}
    2646. PUSH Y
    2647. JSR COMPACT
    2648. MOV A,#,{STRING}
    2649. POP X
    2650. MOV G,E$[]{STRING}
    2651. JSR ARRAYSTORE
    2652. MOV Y,#4{INTEGER}
    2653. MOV X,Z1{REAL}
    2654. ADD X,Y
    2655. MOV Z1{REAL},X
    2656. JMP 710
    2657. SKIP64:
    2658. 448:
    2659. NOP
    2660. 450:
    2661. JSR COMPACT
    2662. MOV B,#ist{STRING}
    2663. MOV A,M${STRING}
    2664. CHGCTX #0
    2665. JSR SEQ
    2666. CMP X,#0{REAL}
    2667. JE SKIP65
    2668. MOV Y,Z2{REAL}
    2669. PUSH Y
    2670. JSR COMPACT
    2671. MOV A,M${STRING}
    2672. POP X
    2673. MOV G,E$[]{STRING}
    2674. JSR ARRAYSTORE
    2675. MOV Y,#4{INTEGER}
    2676. MOV X,Z1{REAL}
    2677. ADD X,Y
    2678. MOV Z1{REAL},X
    2679. JMP 710
    2680. SKIP65:
    2681. 452:
    2682. JSR COMPACT
    2683. MOV B,#snd{STRING}
    2684. MOV A,M${STRING}
    2685. CHGCTX #0
    2686. JSR SEQ
    2687. CMP X,#0{REAL}
    2688. JE SKIP66
    2689. MOV Y,Z2{REAL}
    2690. PUSH Y
    2691. JSR COMPACT
    2692. MOV A,#sind{STRING}