ALGORITHMEN - Teil XVI: Liberté - Fraternité - Pfefferminztee

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Unsere Datenschutzerklärung wurde aktualisiert. Mit der Nutzung unseres Forums akzeptierst Du unsere Datenschutzerklärung. Du bestätigst zudem, dass Du mindestens 16 Jahre alt bist.

    • ALGORITHMEN - Teil XVI: Liberté - Fraternité - Pfefferminztee

      Ein weiterer Versuch, aus der Software-Müllkippe noch-Verwendbares zu retten!
      Na, schau´n wer mal ... :pfeifend:
      Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
    • ...i..tee ist doch drin. Erinnert mich an den Fuchstritt, der in das englische Buchstabier-Alphabet rutschte.
      (jetzt ist auch bei mir der Groschen gefallen: Egalité )

      Wie wär's mit diesem Schnipsel, den ich auf Container umstellen werde...


      Quellcode: Zeitzaehler.inc

      1. 'XProfan X3.1
      2. '(cl) Michael Wodrich
      3. '$I Zeitzaehler.inc
      4. $IFNDEF TICKCOUNTER
      5. $DEFINE TICKCOUNTER
      6. Def %TickCount.MicroSec 1
      7. Def %TickCount.MS 2
      8. Def %TickCount.Sec 3
      9. Declare Quad TickCount.Frequency
      10. Declare Quad TickCount.StartTime
      11. Declare Quad TickCount.StopTime
      12. Declare Long TickCount.DieDLL
      13. Proc TickCount.Init
      14. TickCount.DieDLL = UseDLL("Kernel32.DLL")
      15. TickCount.StartTime = 0
      16. TickCount.StopTime = 0
      17. ImportFunc(TickCount.DieDLL,"QueryPerformanceFrequency","TickCount_QPF")
      18. ImportFunc(TickCount.DieDLL,"QueryPerformanceCounter","TickCount_QPC")
      19. TickCount_QPF(Addr(TickCount.Frequency))
      20. Return TickCount.Frequency
      21. EndProc
      22. Proc TickCount.Exit
      23. FreeDLL TickCount.DieDLL
      24. EndProc
      25. Proc TickCount.Start
      26. TickCount_QPF(Addr(TickCount.Frequency))
      27. TickCount_QPC(Addr(TickCount.StartTime))
      28. Return TickCount.StartTime
      29. EndProc
      30. Proc TickCount.Stop
      31. TickCount_QPC(Addr(TickCount.StopTime))
      32. Return TickCount.StopTime
      33. EndProc
      34. Proc TickCount.Stopp
      35. TickCount_QPC(Addr(TickCount.StopTime))
      36. Return TickCount.StopTime
      37. EndProc
      38. // Parameter: GetTime(Einheit,stopp), GetTime(Einheit,start,stopp), GetTime(Einheit,frequ,start,stopp)
      39. // Einheit =
      40. // %TickCount.MicroSec == 1
      41. // %TickCount.MS == 2
      42. // %TickCount.Sec == 3
      43. Proc TickCount.GetTime
      44. Declare quad start, stopp, frequ, float ergi, int Einheit
      45. Select %PCount
      46. CaseOf 2
      47. Parameters int a0, quad a1
      48. Einheit = a0
      49. stopp = a1
      50. start = TickCount.StartTime
      51. frequ = TickCount.Frequency
      52. CaseOf 3
      53. Parameters int b0, quad b1,b2
      54. Einheit = b0
      55. start = b1
      56. stopp = b2
      57. frequ = TickCount.Frequency
      58. Otherwise // 4 Parameter
      59. Parameters int c0, quad c1,c2,c3
      60. Einheit = c0
      61. frequ = c1
      62. start = c2
      63. stopp = c3
      64. EndSelect
      65. Select Einheit
      66. CaseOf %TickCount.MicroSec
      67. ergi = ((stopp - start) * 1000000) / frequ
      68. CaseOf %TickCount.MS
      69. ergi = (((stopp - start) * 1000000) / frequ) / 1000
      70. CaseOf %TickCount.Sec
      71. ergi = (((stopp - start) * 1000000) / frequ) / 1000000
      72. Otherwise // Hier ist der Vorgabewert "ms"
      73. ergi = (((stopp - start) * 1000000) / frequ) / 1000
      74. EndSelect
      75. Return ergi
      76. EndProc
      77. Proc TickCount.ShowTime
      78. Parameters int Einheit,dezi, float wert
      79. Declare string tmp,form
      80. tmp = Trim$(Str$(dezi))
      81. form = "%8." + if(Len(tmp)=0,"0",tmp) + "f"
      82. Select Einheit
      83. CaseOf %TickCount.MicroSec
      84. form = form + " µs"
      85. CaseOf %TickCount.MS
      86. form = form + " ms"
      87. CaseOf %TickCount.Sec
      88. form = form + " sec"
      89. Otherwise // Hier ist der Vorgabewert "ms"
      90. form = form + " ms"
      91. EndSelect
      92. Return Format$(form,wert)
      93. EndProc
      94. /*
      95. Oder Umrechnung in einen Zeitpunkt:
      96. declare quad starter, stopper, float zeit
      97. TickCount.Init()
      98. starter = TickCount.Start()
      99. ' zu messender Programm-Code
      100. stopper = TickCount.Stop()
      101. zeit = TickCount.GetTime(%TickCount.MS,starter,stopper) / 86400000 'Umrechnung in XProfan-Zeitpunkt
      102. print "benötigte Zeit: " + dt("DateTimeStr","h:nn:ss.zzz",zeit)
      103. */
      104. $ENDIF
      105. 'Zeitpunkt -- h/(1 *24) + Min/(60 *24) + Sec/(60*60 *24) + MS/(60*60*1000 *24)
      Alles anzeigen
      (cl) steht übrigens für CopyLeft

      (ist aus einem Codeschnipsel von Richard Maurukas; ich hoffe, ich erinnere mich an die richtige Namensschreibung)

      P.S.:
      und recherchiert:
      Liberté, Égalité, Fraternité (Freiheit, Gleichheit Brüderlichkeit)

      aus Google:

      Liberté, Égalité, Fraternité – Boarische Wikipedia

      bar.wikipedia.org/wiki/Liberté,_Égalité,_Fraternité

      De Paroin Liberté, Égalité, Fraternité is easchd 50 Joa noch da Franzesischn Revolution, untam Napoléon III., zum Motto vo dera Revolution erkleat woan. Nochdems zwischnduach oiwei wieda in Frog gstejt woan is, hodsa si unta da 3. Republik duachgsetzt. Da Woispruch is in da Vafossung vo 1958 festgschriem. :lol2:
      Programmieren, das spannendste Detektivspiel der Welt.

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von Michael Wodrich () aus folgendem Grund: recherchiert

    • Hätte da eine Frage :

      Michael Wodrich schrieb:

      Proc TickCount.Stop
      TickCount_QPC(Addr(TickCount.StopTime))
      Return TickCount.StopTime
      EndProc

      Proc TickCount.Stopp
      TickCount_QPC(Addr(TickCount.StopTime))
      Return TickCount.StopTime
      EndProc
      Warum zweimal denselben Code in unterschiedlichen Procs
      (TickCount.Stopp & TickCount.Stopp) ?

      Machen doch beide das gleiche.
      Oder sollte eine für QueryPerformanceFrequency und die andere
      für QueryPerformanceCounter stehen ?

      Also Typo-Fehler : TickCount_QPF
    • Link: Aktuelles INHALTSVERZEICHNIS
      ========================
      ... dieser "Algorithmen"-Reihe (Teile I bis XV) als gezippte EXE zum Download. Im zip-File zusätzlich enhalten: Der BEAMER, der einen rasch in die Nähe des entsprechenden Beitrags im richtigen Kapitel hier im Forum bringen soll - als normales, anpassbares .PRF, um den eigenen Browser wählen zu können. (Eingestellt ist die Firefox-32bit-Defaultinstallation auf einem 64-bit Windows 7 SP1).
      Gruss

      P.S.: Eingabe der Kapitelnummer wie üblich als normale arabische, nicht als römische Zahl, getrennt durch Underscore-Zeichen "_" von der gewünschten Beitragsnummer.

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

    • Hallo Heinz,
      das QPC ist schon richtig, es wird ja der Counter gestoppt und nicht die Frequenz, die wird beim Starten nur einmal initialisiert (festgehalten).

      Das Stopp und Stop als zwei unabhängige Funktionen hatte ich mir bei anderen Compilern angewöhnt. Die erkennen, welche Form im Programm dann später aufgerufen wird und entfernen die nicht benutze. Rufft man innerhalb der einen Funktion die andere auf, dann bleiben beide erhalten. Und ja, da andere diese Funktionen aufrufen sollen sind beide Varianten vertreten.

      Diese kleine INI habe ich häufiger im Einsatz und es wird immer mal ein bisschen dran geschraubt.
      - die neuen Datentypen
      - die DT()-Aufrufe mit getestet
      - und nun soll "Container und SubProc" dazu kommen
      Programmieren, das spannendste Detektivspiel der Welt.
    • Abt. Codevergleich
      ============
      Verglichen wird hier die .LST-Datei des XProfan-X4ß Inline-Assemblers im Modus set("asmmode",1) mit dem entsprechenden Disassemblercode, den der Online-Disassembler auf defuse.ca/online-x86-assembler.htm#disassembly2 liefert.

      Das Programm:

      Quellcode

      1. CLS:set("asmmode",1)
      2. ASM "MeineFunktion", 2
      3. mov eax,par1
      4. mov ebx,par2
      5. add eax,ebx
      6. ENDASM
      7. Var Ergebnis& = MeineFunktion(38764, 879879878)
      8. Print Ergebnis&
      9. WaitInput
      Die erzeugte .LST-Datei:

      Quellcode

      1. MeineFunktion - 2
      2. 0000 55 PUSH ebp
      3. 0001 89E5 MOV ebp,esp
      4. 0003 8B4508 MOV eax,par1
      5. 0006 8B5D0C MOV ebx,par2
      6. 0009 01D8 ADD eax,ebx
      7. 000B 89EC MOV esp,ebp
      8. 000D 5D POP ebp
      9. 000E C20800 RET 8
      10. 5589E58B45088B5D0C01D889EC5DC20800
      Alles anzeigen
      Das Disassembler-Ergebnis des Hexcode-Strings in obiger Zeile 13:

      Quellcode

      1. Disassembly
      2. [b]Raw Hex[/b] (zero bytes in bold):
      3. 5589E58B45088B5D0C01D889EC5DC208[b]00[/b]
      4. [b]String Literal:[/b]
      5. "\x55\x89\xE5\x8B\x45\x08\x8B\x5D\x0C\x01\xD8\x89\xEC\x5D\xC2\x08\x00"
      6. [b]Array Literal:[/b]
      7. { 0x55, 0x89, 0xE5, 0x8B, 0x45, 0x08, 0x8B, 0x5D, 0x0C, 0x01, 0xD8, 0x89, 0xEC, 0x5D, 0xC2, 0x08, 0x00 }
      8. Disassembly:
      9. 0: 55 push ebp
      10. 1: 89 e5 mov ebp,esp
      11. 3: 8b 45 08 mov eax,DWORD PTR [ebp+0x8]
      12. 6: 8b 5d 0c mov ebx,DWORD PTR [ebp+0xc]
      13. 9: 01 d8 add eax,ebx
      14. b: 89 ec mov esp,ebp
      15. d: 5d pop ebp
      16. e: c2 08 00 ret 0x8
      Alles anzeigen
      und dessen für XProfan verdaubar gemachte Variante

      Quellcode

      1. L0::db $55 ;push ebp
      2. L1::db $89:db $e5 ;mov ebp,esp
      3. L3::db $8b:db $45:db $08 ;mov eax,DWORD PTR [ebp+$08]
      4. L6::db $8b:db $5d:db $0c ;mov ebx,DWORD PTR [ebp+$0c]
      5. L9::db $01:db $d8 ;add eax,ebx
      6. Lb::db $89:db $ec ;mov esp,ebp
      7. Ld::db $5d ;pop ebp
      8. Le::db $c2:db $08:db $00 ;ret $08

      Im Prinzip könnten hier also auch ältere Maschinenprogramme (etwa solche mit INT(21)-Funktionen) angepasst und im Kern weiterverwendet werden. Weiters erscheint mit diesem Online-Tool die Anpassung an 64-bit-Systeme möglich, ohne lokal einen Voll-Assembler aufsetzen zu müssen!
      Gruss

      P.S.: Selbstverständlich sind dabei Urheberrechte zu beachten!

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von p. specht ()

    • Lösung zu SwR 1
      -------------------
      Die Antwort liefert wie so oft ein kleines XProfan-Programm:

      Quellcode

      1. Cls:font 2:declare a$,b$,c$,d$, e$,f$,g$,h$, i$,j$,k$,l$, m$,n$,o$,p$, z!
      2. whileloop 0,1:a$=&Loop:whileloop 0,1:b$=&Loop:whileloop 0,1:c$=&Loop
      3. whileloop 0,1:d$=&Loop:whileloop 0,1:e$=&Loop:whileloop 0,1:f$=&Loop
      4. :whileloop 0,1:g$=&Loop:whileloop 0,1:h$=&Loop:whileloop 0,1:i$=&Loop
      5. :whileloop 0,1:j$=&Loop:whileloop 0,1:k$=&Loop:whileloop 0,1:l$=&Loop:print ".";
      6. :whileloop 0,1:m$=&Loop:whileloop 0,1:n$=&Loop:whileloop 0,1:o$=&Loop
      7. :whileloop 0,1:p$=&Loop:z!=val(a$+b$+c$+d$+e$+f$+g$+h$+i$+j$+k$+l$+m$+n$+o$+p$)
      8. if (z!>0) and (z!=225*int(z!/225)):print "\n Die Zahl ist ";format$("################0",z!);
      9. print " / 225 = ";z!/225," d.s.",len(format$("################0",z!)),"Stellen!"
      10. sound 2000,200:waitinput:endif
      11. endwhile:endwhile:endwhile:endwhile:endwhile:endwhile:endwhile:endwhile
      12. endwhile:endwhile:endwhile:endwhile:endwhile:endwhile:endwhile:endwhile
      13. Print "\n ...keine (weiteren) gefunden!":sound 100,400:waitinput:end
      Alles anzeigen
    • Abt. Das Sprung-Desaster
      =================

      A. Bedingte Sprünge:

      CF: Carry flag; ZF: Zero flag; SF: Sign flag; OF: Overflow flag;
      DF: Direction flag; PF: Parity flag (0 = gerade Anzahl von 1-bits, 1 = ungerade bit-Summe)

      Opcode Description CPU Flags
      -----------------------------------
      JA Above CF = 0 and ZF = 0
      JAE Above or equal CF = 0
      JB Bellow CF
      JBE Bellow or equal CF or ZF
      JC Carry CF
      JE Equality ZF
      JG Greater (s) ZF = 0 and SF = OF
      JGE Greater of equal(s) SF = OF
      JL Less (s) SF ≠ OF
      JLE Less or equal (s) ZF or SF ≠ OF
      JNA Not above CF or ZF
      JNAE Neither above nor equal CF
      JNB Not bellow CF = 0
      JNBE Neither bellow nor equal CF = 0 and ZF = 0
      JNC Not carry CF = 0
      JNE Not equal ZF = 0
      JNG Not greater ZF or SF ≠ OF
      JNGE Neither greater nor equal SF ≠ OF
      JNL Not less SF = OF
      JNLE Not less nor equal ZF = 0 and SF = OF
      JNO Not overflow OF = 0
      JNP Not parity PF = 0
      JNS Not negative SF = 0
      JNZ Not zero ZF = 0
      JO Overflow (s) OF
      JP Parity PF
      JPE Parity PF
      JPO Not parity PF = 0
      JS Negative (s) SF
      JZ Null ZF
      -----
      (s) signed = Unter Beachtung des Vorzeichen-bits

      Ausnahmen:
      JECXZ hängt nicht vom EFLAG Register ab, sondern vom ´decremented ECX´= 0.


      B. Unconditional jump: JMP
      ----------------------------

      C. Äquivalente Codes:
      ----------------------
      JB ≡ JC ≡ JNAE
      JAE ≡ JNB ≡ JNC
      JE ≡ JZ
      JNE ≡ JNZ
      JBE ≡ JNA
      JA ≡ JNBE
      JP ≡ JPE
      JNP ≡ JPO
      JL ≡ JNGE
      JGE ≡ JNL
      JLE ≡ JNG
      JG ≡ JNLE

      D. Ohne Äquivalenz:
      ---------------------
      JO
      JNO
      JS
      JNS

      Gruss

      P.S.: Kennt jemand diese Debugging tools? Sieht eher verdächtig aus ...

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

    • Abt. Karrierewege von Informatik-Profis
      =============================
      Aus einem öffentlichen Youtube-Vortrag (engl.):

      [IMG:http://members.aon.at/startup/Developer.gif]

      Zentrale Funktion scheinen hier die TeamleiterInnen einzunehmen - die erste Managementstufe, in der aber immer noch die Tätigkeit des Programmierens eine große Rolle spielt und unterschiedliche Wege offenstehen.

      Gruss

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von p. specht ()

    • Abt. Grundsätzliche Speicheradressierungsmethoden
      =======================================

      A) Ladeadress- bzw. positionsunabhängiger Code
      -----------------------------------------------
      verwendet ausschließlich relative Adressierung, also Sprungdistanzen (bezogen auf den jeweiligen Stand des "Program Instruction Pointers" EIP *nach* Ausführung des Maschinenbefehls, also der nächsten unverzweigten Speicheradresse). Es ist eine sehr nützliche Art von Code, weil das bedeutet, dass keine Anpassungen nach dem Laden erforderlich sind und mit der Abarbeitung sofort begonnen werden kann. Leider wird diese Adressierungsart von x86-Prozessoren nur bei bestimmten Befehlen unterstützt.


      B) "Relokatible" Adressierung
      ----------------------------
      verwendet verschieblichen Code relativ zum jeweiligen Programmbeginn bzw. zur noch absolut oder relativ zur Verfügung zu stellenden Label-Adresse. Die zuerst nur symbolisch vorliegenden Adressen sind daher im konkreten Fall nach dem Laden noch anzupassen - das ist Aufgabe des Linkers (... oder im Falle eines ´Interpreters von Inline-Code´ dessen zusätzliche Aufgabe, stark unterstützt vom Betriebssystem). Hat man keinen solchen Relocator zur Verfügung, wird blosses Laden und Anspringen nicht klappen, oder nur beim ersten Mal.

      Leider verwenden viele x86-Befehle diese Adressierungsart. Das hat historische Gründe: Früher erfolgte die Speicherverwaltung über die CPU-Segmentregister, und da der Speicherbereich somit nicht zusammenhängend erschien (Was heute durch die Memory Management Unit MMU gewährleistet wird), war ohnehin noch ständige Adressanpassung erforderlich. Erst die x86-64-bit Version kennt heute jeweils auch rein EIP/RIP-relativen positionsunabhängigen Code.


      C) Absolute Adressierung
      ------------------------
      bezieht sich auf eine ganz konkrete Speicheradresse, was vor allem im Mikroprozessorsystemen mit wenig Speicher üblich ist. Vorteil: Es ist die schnellste Art von Code.

      Q: stackoverflow.com/questions/22…and-absolute-machine-code

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von p. specht ()

    • Zur Hüpferei in Assembler:

      Wenn im XProfan-Inline-Assembler Lablels innerhalb der ASM-Routine mit JUMP oder CALL angesprungen werden, sind die Sprungentfernungen auch hier relativ zum augenblicklichen EIP nach Ausführung des Befehls, dürfen aber über die -127 bis +128 bei den anderen Sprüngen hinaus gehen (A). Solange man sich darauf beschränkt, ist der erzeugte Maschinencode also verschiebbar.

      Wenn ich aus der ASM-Routine aber eine eine importierte Funktion (dazu zählen auch andere mit ASM erzeugte Funktionen) mit CALL @NAME aufrufe, ist der Code nicht mehr verschiebbar. Ebenso, wenn ich Adressen aus geladenen DLLs oder von XProfan-Prozeduren als Parameter verwende, um sie aus der ASM-Routine heraus aufzurufen. In diesem Fällen wird nämlich eine direkte Adresse (C) angegeben.

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4


      http://www.xprofan.de
    • @Michael Wodrich: Ersatz wäre z.B. JECXZ <rel8> = db $e3 db <+128=$7F,-127=$FF>

      Hinweis @RGH: Folgende Zeichen machen noch Erfassungsprobleme: 129,141,143 144 und 157
      und zwar weil sie (zumindest in LemonEd) keinen Zeichenabstand schreiben. Sind sie aber in einem String erst vorhanden,dann kann man sie zusammen mit den anderen Zeichen "mitgrabben". Eleganter wäre, sie durch \x81, \x8D, \x8F\x90 und \x9D ersetzen zu können. Frage: Geht das?
    • p. specht schrieb:

      @Michael Wodrich: Ersatz wäre z.B. JECXZ <rel8> = db $e3 db <+128=$7F,-127=$FF>

      Hinweis @RGH: Folgende Zeichen machen noch Erfassungsprobleme: 129,141,143 144 und 157
      und zwar weil sie (zumindest in LemonEd) keinen Zeichenabstand schreiben. Sind sie aber in einem String erst vorhanden,dann kann man sie zusammen mit den anderen Zeichen "mitgrabben". Eleganter wäre, sie durch \x81, \x8D, \x8F\x90 und \x9D ersetzen zu können. Frage: Geht das?
      Ein Zeichen im String durch seinen Hexcode mit "\xNN" zu ersetzen, geht immer. So kannst Du das " wahlweise durch "\q" oder "\x22" ersetzen.

      Gruß
      Roland
      Intel Duo E8400 3,0 GHz / 4 GB RAM / 1000 GB HDD / ATI Radeon HD4770 512 MB / Windows 7(32) - XProfan X4
      AMD Athlon II X2 2,9 GHz / 3 GB RAM / 500 GB HDD / ATI Radeon 3000 (onboard) / Windows 10(64) - XProfan X4


      http://www.xprofan.de
    • Abt. BITCOIN SOUND 03/2018
      ====================
      Keine nähere Erklärung nötig. Spielerei ohne jede Gewähr!
      Gruss

      Quellcode

      1. WindowTitle "EURO/BITCOIN SOUND - April 2017 BIS März 2018"
      2. WindowStyle 24:Window 770,500 '(CL) 2018-03 P.Specht, Wien
      3. CLS:declare s&,data$[]:Data$[]=explode(\
      4. "27,28,28,28,28,28,28,28,28,28,29,29,29,29,29,"+\
      5. "30,30,30,30,30,30,30,30,30,30,29,29,29,29,29,"+\
      6. "29,30,30,30,30,30,30,30,30,30,30,30,30,30,30,"+\
      7. "30,30,30,31,31,31,31,31,31,31,31,31,32,32,32,"+\
      8. "33,33,34,34,35,35,35,36,36,37,37,37,37,37,38,"+\
      9. "38,39,40,41,41,41,42,42,43,44,43,43,42,42,42,"+\
      10. "42,41,41,41,42,42,42,43,43,43,44,45,46,47,49,"+\
      11. "49,50,50,51,53,54,56,57,59,58,57,56,55,53,52,"+\
      12. "52,52,53,53,52,52,53,54,55,55,55,56,57,58,60,"+\
      13. "61,63,65,65,64,64,64,64,63,64,64,65,65,64,64,"+\
      14. "64,63,63,62,62,61,59,57,55,56,56,57,58,58,59,"+\
      15. "60,61,61,62,62,62,62,62,62,62,62,62,60,58,56,"+\
      16. "56,56,56,56,57,58,58,58,58,57,57,57,57,57,57,"+\
      17. "58,59,59,59,58,59,59,59,59,58,58,57,56,56,55,"+\
      18. "54,53,53,53,53,53,53,53,53,52,52,50,48,47,49,"+\
      19. "51,51,51,52,52,54,55,56,58,60,60,60,61,61,60,"+\
      20. "59,58,57,56,56,56,57,58,59,60,61,61,61,61,61,"+\
      21. "61,61,60,60,60,60,60,60,61,62,66,70,72,73,74,"+\
      22. "74,74,74,74,74,74,74,75,76,79,84,89,91,91,91,"+\
      23. "91,91,91,92,93,94,95,94,93,93,91,90,88,87,86,"+\
      24. "87,88,90,91,91,91,92,93,95,95,94,93,93,94,96,"+\
      25. "96,97,98,99,100,101,102,103,104,103,100,97,95,"+\
      26. "94,93,95,97,98,98,99,99,98,97,96,95,93,91,91,"+\
      27. "91,92,90,88,85,83,81,79,77,76,76,80,84,85,85,"+\
      28. "85,85,85,84,84,82,80,78,78,78,78,80,82,83,84,"+\
      29. "85,85,86,88,89,90,91,91,91,91,92,94,96,96,95,"+\
      30. "94,94,94,93,93,93,93,94,94,96,98,100,101,103,"+\
      31. "104,105,105,104,104,107,109,112,116,120,122,"+\
      32. "122,122,123,122,122,122,121,119,118,120,122,"+\
      33. "123,123,124,125,126,127,128,126,125,123,122,"+\
      34. "121,122,124,126,126,127,128,130,132,135,135,"+\
      35. "136,137,139,141,144,147,150,153,155,157,159,"+\
      36. "159,159,160,159,158,157,159,161,162,162,161,"+\
      37. "160,159,156,154,151,146,141,141,143,145,148,"+\
      38. "151,154,157,160,163,166,168,171,173,175,176,"+\
      39. "177,178,178,178,178,179,178,177,177,177,177,"+\
      40. "185,195,205,207,209,211,215,220,224,225,221,"+\
      41. "218,221,227,234,239,245,250,250,251,256,271,"+\
      42. "286,304,326,349,364,363,357,352,353,358,362,"+\
      43. "366,369,372,370,363,356,354,355,361,369,377,"+\
      44. "386,396,405,409,405,395,384,374,366,358,350,"+\
      45. "344,337,329,319,309,303,300,309,323,337,338,"+\
      46. "336,334,332,326,318,310,308,307,307,301,295,"+\
      47. "295,304,312,315,319,322,323,322,324,337,350,"+\
      48. "360,359,346,333,319,315,311,312,315,317,316,"+\
      49. "303,291,285,288,290,289,286,284,279,263,247,"+\
      50. "235,234,233,233,234,235,237,240,241,238,233,"+\
      51. "227,225,225,227,230,233,234,232,231,230,229,"+\
      52. "228,228,229,230,230,225,217,209,208,209,209,"+\
      53. "202,195,187,184,182,181,170,156,148,154,159,"+\
      54. "159,158,158,163,168,173,176,178,181,182,183,"+\
      55. "184,184,181,179,185,191,195,199,203,206,207,"+\
      56. "208,213,220,227,230,230,231,232,229,224,219,"+\
      57. "215,210,206,207,210,211,212,213,215,218,220,"+\
      58. "221,219,218,219,222,226,227,227,228,231,234,"+\
      59. "237,238,233,227,221,215,210,204,200,196,193,"+\
      60. "192,192,191,190,189,189,189,188,188,181,175,"+\
      61. "170,171,171,172,172,173,175,176,179,182,185,"+\
      62. "187,186,185,184,183,182,181,182,183,184,182,176" ,",")
      63. Print "\n Apr.2017 Mai Juni Juli Aug. Sept. "+\
      64. "Okt. Nov. Dez. | Jan.2018 Feb. März"
      65. print "\n SYMBOLISCHE DARSTELLUNG OHNE JEDE GEWÄHR!"
      66. usepen 0,1,rgb(0,0,200):font 2
      67. Whileloop sizeof(Data$[])-1
      68. s&=val(Data$[&Loop])
      69. sound 8*s&,44:locate 6,36
      70. print " Kurs: ";int(round(s&*36, 0));" ";
      71. line &loop,420-&Loop,420-s&*.9
      72. waitinput 60
      73. endwhile
      74. waitinput 8000
      75. end
      Alles anzeigen