ALGORITHMEN UND ANDERES ZEUG - Teil XIII

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 UND ANDERES ZEUG - Teil XIII

    Auch diesmal wieder: Herzliche Einladung zum experimentieren und zum lustvollen Scheitern auf unsere Software-Müllkippe. Hier bleibt kein Auge trocken - hoffentlich vor Lachen...
    Gruss

    P.S.: Hier ein Link auf ein gezipptes Inhaltsverzeichnis mit Suchprogramm betreffend alle bisherige Teile (I - XII) unserer ALGORITHMEN-Serie. Hinweis: Römische Kapitelziffern wurden aus technichen Gründen in zweistellige arabische Zahlen mit zwei nachgestellten Underscores umgewandelt.Aus II wird also 02__+Beitragsnummer im jeweiligen Kapitel.
    Win7-64HomPremSP1,XProfan11.2a,XPIA,JWasm,xpse,IntelCoreQuad2.5GHz/4GB/je1TB HD intern:esataBay:USB3
  • Abt. Doch unbewiesen? Die Collatz-Vermutung
    =============================
    Im Juni 2011 meldete ´Der Spiegel´ die angebliche Lösung der nun 66 Jahre alten Vermutung des deutschen Mathematikers Lothar Collatz, wonach für jede beliebig große natürliche Zahl N, auf die wiederholt eine einfache Regel angewandt wird, eine zugeordnete Folge entsteht, die letztlich irgendwann immer in den Zyklus 1, 4, 2, 1, 4, 2, 1,... übergeht. 2011 dachte man, diese "einfache" Angelegenheit mit komplexen zahlentheoretischen Methoden bewiesen zu haben. Allein, später kamen Zweifel auf, ob der Beweis wirklich alle Fälle abdeckt!

    Die Regel lautet: Ist N gerade, dann halbiere N, andernfalls bilde N:=3*N+1

    und sie ist so einfach, daß man sie auch durch Einsatz des neuen Profan X4-Inline Assemblers gewaltig beschleunigen könnte. Von Spezialisten wurden alle Ganzzahlen bis 5*2^60 geprüft und die Regel bestätigt. Mathematiker wollen es aber genauer wissen, und beissen sich offenbar nach wie vor die Zähne aus.

    Anbei ein kleines Progi, daß diejenigen Zahlen und ihre zugehörige Zykluszahl ausgibt, wenn wieder ein neuer Zyklusrekord erreicht wurde. ... Allerdings ohne Assembler: Vielleicht hat ja wer Lust, den Bereich über 5*2^60 zu erkunden :P !
    Gruss

    P.S.: Für negative Zahlen wurden (bisher) genau drei solche Zyklen gefunden!

    Quellcode

    1. Windowtitle "Die Collatz-Vermutung [1937]: Jedes n aus |N- führt zu Zyklen!"
    2. WindowStyle 24:Window 0,0-%maxx,%maxy:showmax:font 2
    3. print "\n Die Regel: Wenn n gerade, n=n/2. Wenn n ungerade, n=3*n+1"
    4. print "\n Dann gilt vermutlich: Es gibt 5 bekannte Collatz-Zyklen für sInt:\n"
    5. print "\n I) 1,4,2,1,.. (Gültigkeit geprüft für n>0 bis n=5*2^60)"
    6. print "\n II) 0,0,.. Trivialer Fall"
    7. print "\n III) -1,-2,-1,.. für negative Ganzzahlen, dann weiters nurmehr:"
    8. print "\n IV) -5,-14,-7,-20,-10,-5,.."
    9. print "\n V) -17,-50,-25,-74,-37,-110,-55,-164,-82,-41,"
    10. print " -122,-61,-182,-91,-272,-136,-68,-34,-17,..\n\n"
    11. declare n&,m&,z&,max&
    12. Print " Collatz-Rekordhalter:\n"
    13. whileloop 2^28:n&=&Loop:m&=n&
    14. repeat
    15. whilenot n& mod 2
    16. inc z&:n&=n&>>1
    17. endwhile
    18. if (n&=1)
    19. if z&>max&:max&=z&
    20. Print m&;":";z&;" ";
    21. clear z&
    22. endif
    23. break
    24. endif
    25. n&=3*n&+1
    26. until 0
    27. endwhile
    Alles anzeigen

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

  • Abt. JSON
    =======
    XProfan unterstützt in der kommenden Version X4 nun JSON, das weltweit stark verbreitete, an JavaScript/ECMAscript angelehnte Datenaustauschformat. Hier einige Links , u.a. auf das entsprechende RFC-Dokument. Es handelt sich um eine gute Alternative zum eher schwierig zu handhabenden XML-Format.

    Weiters habe ich die vorläufigen Angaben von Profan-Chef RGH in ein Pdf-Merkblatt zu X4-JSON umgesetzt, ich hoffe, das geht OK. Inhaltlich ist die Sache ident, geht aber auf eine einzige Seite.

    Gruss

    P.S.: Einige Nachteile von JSON sollten nicht verschwiegen werden, treten aber erst bei komplexen Anwendungen zutage.

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

  • Abt. Quaternions, Teil I
    ==================
    Eine beliebige Rotation eines 3D-Körpers um einen Ursprung im Raum kann dargestellt werden durch Angabe einer Drehachsenrichtung (= Einheitsvektor vom Ursprung des Koordinatensystems zu einem 3D-Raumpunkt auf der Einheitskugel) PLUS einer "Rotationsgröße" um diese Achse. Diese Rotationsgrößenangabe stellt sozusagen eine weitere Dimension dar. Der komplette Rotationsvorgang kann also durch eine vierdimensionale Größe beschrieben werden, die in der Mathematik Schraubung genannt wird (ein Konzept, daß besonders in Frankreich populär ist).

    Vorstellen könnte man sich die Rotationsgröße als die Hälfte des Winkels zwischen ursprünglicher und rotierter Lage des Körpers. Warum die Hälfte? Nun, aus folgendem Grund: Das Konzept der Quaternions möchte Winkelrotationen generell vermeiden - unter anderem, weil bei Winkelangaben (z.B. Eulerwinkeln) Totpunkte entstehen (vgl. Kurbeltrieb), insbesondere aber, weil man in einem Rutsch glatte Rotationsbewegungen linear interpolieren möchte (Ego-Perspektive in Games!), was aber bei Sinus/Cosinus-Berechnungen nur gliedweise klappt und hohen Rechenaufwand, Zeit- und Genauigkeitsverlust verursacht! (Anm.: Als ´Transzendente Funktionen´ sind Hardcore-Mathematikern Sinus und Cosinus ohnehin suspekt).

    Statt dessen wird beim Konzept "Quaternion" auf elegante Weise mit doppelten Spiegelungen gearbeitet. Doppelt, weil bei einfacher Spiegelung der Drehsinn nicht erhalten bliebe. (Anmerkung: Der Halbwinkel - wenn man schon unbedingt in Winkeln denken will, dient also nicht zur Rotation zum Dreh-Endpunkt des Körpers, sondern stellt den Winkel zur Spiegelebene im Raum dar). Die Lage der Spiegelebene im Raum wird dann durch ihre Normale, eben einen Richtungsvektor angegeben.

    Eine kleine begriffliche Schwierigkeit ist noch zu erläutern: Es handelt es sich bei dieser Spiegelebene nicht um einen einseitigen Haushaltsspiegel in einiger Entfernung (- da wäre ja dann Translationsbewegung dabei), sondern diese Ebene geht durch den Ursprung des vierdimensionalen Koordinatensystems, stellt also eher eine Symmetrieebene dar, an der von allen Seiten gespiegelt wird*). Penible Mathematiker sehen darin eine Scheerung in der 4. Dimension, die sich im 3D-Raum als Rotation manifestiert.

    Das ganze scheint damit etwas abstrakt, aber Quaternions sind mathematisch sehr vorteilhaft, und zwar nicht nur bei Drehungen (z.B. Exponentiation)! Das Konzept wurde angeblich beim Spiel Tomb Raider I (Lara Crofts Abenteuer) - auszugsweise nun freeware - erstmals konsequent umgesetzt, Quaternionen finden aber in der Physik schon seit ihrer Erfindung durch W.R.Hamilton AD 1843 Anwendung und sind eine schnelle Alternative zu Drehmatrizen. In OpenGL finden sich übrigens beide Verfahren.

    Gruss

    *) P.S.: Eine gewissen Verwandtschaft zum CORDIC-Algorithmus zum Berechnen einiger Winkelfunktionen ist damit auch gegeben.

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

  • Abt. Selbstreplikative Sequenzen
    ====================
    Das von Kolakoski 1965 in American Mathematics Montly veröffentlichte Problem stellt die Frage, ob es neben der von ihm und anderen gefundenen Folge noch weitere stabil-selbstreplikative Sequenzen gibt. Zählt man nämlich jeweils die Anzahl gleicher Elemente nebeneinander und reiht sie aneinander, dann entsteht wieder die Folge.

    Auch ist die Frage, ob Gleichverteilung der Elemente der Folge vorliegt, bisher nur empirisch bis 10^13 erwiesen. Zum Limes 1/2 konvergiert der "laufende Mittelwert" auch nur langsam. Die aktuell erwiesene Eingrenzung lautet 0.499 <= Limes <= 0.501. Anbei der erzeugende Algorithmus der Folge als Prinzipstudie.

    Gruss

    Quellcode

    1. WindowTitle "The self-replicating Kolakoski-Sequence [1965, American Math montly]"
    2. 'Source: https://en.wikipedia.org/wiki/Kolakoski_sequence
    3. 'Als mit offenen Problemen erwähnt in: https://www.youtube.com/watch?v=BflyQyBi7y4
    4. WindowStyle 24:Window 0,0-%maxx,%maxy:showmax:font 2
    5. ' This algorithm takes linear time, but because it needs to refer back to earlier positions in
    6. ' the sequence it needs to store the whole sequence, taking linear space. An alternative algorithm
    7. ' that generates multiple copies of the sequence at different speeds, with each copy of the
    8. ' sequence using the output of the previous copy to determine what to do at each step, can be used
    9. ' to generate the sequence in linear time and only logarithmic space.
    10. ' For that see http://www.emis.ams.org/journals/JIS/VOL15/Nilsson/nilsson5.pdf
    11. Declare a$,i&,xi&,b$
    12. b$="12211212212211211221211212211"
    13. font 0:print " ";b$:font 2 ' zur Kontrolle
    14. lup:
    15. 'In the ith iteration, read the value xi that has already been output as the ith value
    16. 'of the sequence (or, if no such value has been output yet, sets xi = i).
    17. xi&=val(mid$(a$,i&,1)):case xi&=0:xi&=i&
    18. if i& mod 2 ' Then, if i is odd, it outputs xi copies of the number "1"
    19. a$=a$+mkstr$("1",xi&)
    20. else ' while if i is even, it outputs xi copies of the number "2".
    21. a$=a$+mkstr$("2",xi&)
    22. endif
    23. inc i&
    24. print " ";a$ :waitinput 1000
    25. if %csrlin>52:locate 1,1:font 0:print " ";b$:font 2:endif
    26. goto "lup"
    Alles anzeigen

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

  • Abt. FPU
    ======
    Die Floating Point Unit der heutigen PCs ist in die CPU integriert und wird vom CISC-emulierenden RISC-Prozessor (on Chip asynchron zwischen 80 und 120 GHz schnell) ebenfalls nur emuliert. Dennoch wäre eine gewaltige Beschleunigung möglich. Zur leichteren Handhabung in späteren Einsatzfällten nachstehend eine "explodierbare" Aufstellung dieser mit "F" beginnenden Befehle aus dem Intel-Handbuch.
    Gruss

    Quellcode

    1. cls
    2. var FPU_INSTRUCTIONS$="\
    3. D9 F0;F2XM1\n\
    4. D9 E1;FABS\n\
    5. D8 /0;FADD m32fp\n\
    6. DC /0;FADD m64fp\n\
    7. D8 C0+i;FADD ST(0), ST(i)\n\
    8. DC C0+i;FADD ST(i), ST(0)\n\
    9. DE C0+i;FADDP ST(i), ST(0)\n\
    10. DE C1;FADDP\n\
    11. DA /0;FIADD m32int\n\
    12. DE /0;FIADD m16int\n\
    13. DF /4;FBLD m80dec\n\
    14. DF /6;FBSTP m80bcd\n\
    15. D9 E0;FCHS\n\
    16. 9B DB E2;FCLEX\n\
    17. DB E2;FNCLEX\n\
    18. DA C0+i;FCMOVB ST(0), ST(i)\n\
    19. DA C8+i;FCMOVE ST(0), ST(i)\n\
    20. DA D0+i;FCMOVBE ST(0), ST(i)\n\
    21. DA D8+i;FCMOVU ST(0), ST(i)\n\
    22. DB C0+i;FCMOVNB ST(0), ST(i)\n\
    23. DB C8+i;FCMOVNE ST(0), ST(i)\n\
    24. DB D0+i;FCMOVNBE ST(0), ST(i)\n\
    25. DB D8+i;FCMOVNU ST(0), ST(i);avaliable if CPUID´s CMOV and FPU feature bits are set\n\
    26. D8 /2;FCOM m32fp\n\
    27. DC /2;FCOM m64fp\n\
    28. D8 D0+i;FCOM ST(i)\n\
    29. D8 D1;FCOM\n\
    30. D8 /3;FCOMP m32fp\n\
    31. DC /3;FCOMP m64fp\n\
    32. D8 D8+i;FCOMP ST(i)\n\
    33. D8 D9;FCOMP\n\
    34. DE D9;FCOMPP\n\
    35. DB F0+i;FCOMI ST, ST(i)\n\
    36. DF F0+i;FCOMIP ST, ST(i)\n\
    37. DB E8+i;FUCOMI ST, ST(i)\n\
    38. DF E8+i;FUCOMIP ST, ST(i)\n\
    39. D9 FF;FCOS\n\
    40. D9 F6;FDECSTP\n\
    41. D8 /6;FDIV m32fp\n\
    42. DC /6;FDIV m64fp\n\
    43. D8 F0+i;FDIV ST(0), ST(i)\n\
    44. DC F8+i;FDIV ST(i), ST(0)\n\
    45. DE F8+i;FDIVP ST(i), ST(0)\n\
    46. DE F9;FDIVP\n\
    47. DA /6;FIDIV m32int\n\
    48. DE /6;FIDIV m16int\n\
    49. D8 /7;FDIVR m32fp\n\
    50. DC /7;FDIVR m64fp\n\
    51. D8 F8+i;FDIVR ST(0), ST(i)\n\
    52. DC F0+i;FDIVR ST(i), ST(0)\n\
    53. DE F0+i;FDIVRP ST(i), ST(0)\n\
    54. DE F1;FDIVRP\n\
    55. DA /7;FIDIVR m32int\n\
    56. DE /7;FIDIVR m16int\n\
    57. DD C0+i;FFREE ST(i)\n\
    58. DE /2;FICOM m16int\n\
    59. DA /2;FICOM m32int\n\
    60. DE /3;FICOMP m16int\n\
    61. DA /3;FICOMP m32int\n\
    62. DF /0;FILD m16int\n\
    63. DB /0;FILD m32int\n\
    64. DF /5;FILD m64int\n\
    65. D9 F7;FINCSTP\n\
    66. 9B DB E3;FINIT\n\
    67. DB E3;FNINIT\n\
    68. DF /2;FIST m16int\n\
    69. DB /2;FIST m32int\n\
    70. DF /3;FISTP m16int\n\
    71. DB /3;FISTP m32int\n\
    72. DF /7;FISTP m64int\n\
    73. DF /1;FISTTP m16int\n\
    74. DB /1;FISTTP m32int\n\
    75. DD /1;FISTTP m64int\n\
    76. D9 /0;FLD m32fp\n\
    77. DD /0;FLD m64fp\n\
    78. DB /5;FLD m80fp\n\
    79. D9 C0+i;FLD ST(i); pushing register ST(0) duplicates the stack top\n\
    80. D9 E8;FLD1\n\
    81. D9 E9;FLDL2T\n\
    82. D9 EA;FLDL2E\n\
    83. D9 EB;FLDPI\n\
    84. D9 EC;FLDLG2\n\
    85. D9 ED;FLDLN2\n\
    86. D9 EE;FLDZ\n\
    87. D9 /5;FLDCW m2byte; Loads the 16-bit source operand into the FPU control word. Clear any pending exceptions!\n\
    88. D9 /4;FLDENV m14/28byte\n\
    89. D8 /1;FMUL m32fp\n\
    90. DC /1;FMUL m64fp\n\
    91. D8 C8+i;FMUL ST(0), ST(i)\n\
    92. DC C8+i;FMUL ST(i), ST(0)\n\
    93. DE C8+i;FMULP ST(i), ST(0)\n\
    94. DE C9;FMULP\n\
    95. DA /1;FIMUL m32int\n\
    96. DE /1;FIMUL m16int\n\
    97. D9 D0;FNOP\n\
    98. D9 F3;FPATAN\n\
    99. D9 F8;FPREM\n\
    100. D9 F5;FPREM1\n\
    101. D9 F2;FPTAN\n\
    102. D9 FC;FRNDINT\n\
    103. DD /4;FRSTOR m94/108byte\n\
    104. 9B DD /6;FSAVE m94/108byte\n\
    105. DD /6;FNSAVE m94/108byte\n\
    106. D9 FD;FSCALE\n\
    107. D9 FE;FSIN\n\
    108. D9 FB;FSINCOS\n\
    109. D9 FA;FSQRT\n\
    110. D9 /2;FST m32fp\n\
    111. DD /2;FST m64fp\n\
    112. DD D0+i;FST ST(i)\n\
    113. D9 /3;FSTP m32fp\n\
    114. DD /3;FSTP m64fp\n\
    115. DB /7;FSTP m80fp\n\
    116. DD D8+i;FSTP ST(i)\n\
    117. 9B D9 /7;FSTCW m2byte\n\
    118. D9 /7;FNSTCW m2byte\n\
    119. 9B D9 /6;FSTENV m14_28byte\n\
    120. D9 /6;FNSTENV m14_28byte\n\
    121. 9B DD /7;FSTSW m2byte\n\
    122. 9B DF E0;FSTSW AX\n\
    123. DD /7;FNSTSW m2byte\n\
    124. DF E0;FNSTSW AX\n\
    125. D8 /4;FSUB m32fp\n\
    126. DC /4;FSUB m64fp\n\
    127. D8 E0+i;FSUB ST(0), ST(i)\n\
    128. DC E8+i;FSUB ST(i), ST(0)\n\
    129. DE E8+i;FSUBP ST(i), ST(0)\n\
    130. DE E9;FSUBP\n\
    131. DA /4;FISUB m32int\n\
    132. DE /4;FISUB m16int\n\
    133. D8 /5;FSUBR m32fp\n\
    134. DC /5;FSUBR m64fp\n\
    135. D8 E8+i;FSUBR ST(0), ST(i)\n\
    136. DC E0+i;FSUBR ST(i), ST(0)\n\
    137. DE E0+i;FSUBRP ST(i), ST(0)\n\
    138. DE E1;FSUBRP\n\
    139. DA /5;FISUBR m32int\n\
    140. DE /5;FISUBR m16int\n\
    141. D9 E4;FTST\n\
    142. DD E0+i;FUCOM ST(i)\n\
    143. DD E1;FUCOM\n\
    144. DD E8+i;FUCOMP ST(i)\n\
    145. DD E9;FUCOMP\n\
    146. DA E9;FUCOMPP\n\
    147. D9 E5;FXAM\n\
    148. D9 C8+i;FXCH ST(i)\n\
    149. D9 C9;FXCH; Exmpl:FXCH ST(3):FSQRT:FXCH ST(3)\n\
    150. D9 F4;FXTRACT\n\
    151. D9 F1;FYL2X\n\
    152. D9 F9;FYL2XP1\n\
    153. ;; NP 0F AE /1 FXRSTOR m512byte\n\
    154. ;; NP REX.W + 0F AE /1 FXRSTOR64 m512byte\n\
    155. ;; NP 0F AE /0 FXSAVE m512byte\n\
    156. ;; NP REX.W + 0F AE /0 FXSAVE64 m512byte Rem Bytes 464:511 are available to software use.\n\
    157. ;; Op/En Operand_1 Operand_2 Operand_3 Operand_4 \n\
    158. ;; M ModRM:r/m (r\w) NA NA NA"
    159. print FPU_INSTRUCTIONS$
    160. Waitinput
    Alles anzeigen
  • Abt. Was die Intel-Hieroglyphen bedeuten
    ==========================
    Dazu gibt es HIER eine ausgezeichnete Darstellung als Auszug aus dem Intel-Handbuch 2a) Punkt 3.1.1.1 (leider nur auf Englisch). Aber es gibt ja Google Translate!
    Gruss
    Spoiler anzeigen

    So lesen Sie die Intel Opcode Notation
    ==============================
    Ich lese da Material über Intel Opcodes der Montageanleitung, aber ich kann nicht verstehen, was bedeutet es, was das ist das dem Opcode-Byte folgt. Beispiel: "cw", "cd", "/ 2", "cp", "/ 3". Wo finde ich eine ? Danke im Voraus!


    E8 cw CALL rel16 Anruf nahe, relativ, Verschiebung relativ zum nächsten Befehl


    E8 cd CALL rel32 Anruf nahe, relativ, Verschiebung relativ zum nächsten Befehl


    FF / 2 CALL r / m16 Anrufen nahe, absolut indirekt, Adresse in r / m16 angegeben


    FF / 2 CALL r / m32 Anruf nahe, absolute indirekte Adresse in r / m32 angegeben


    9A cd CALL ptr16: 16 Rufen Sie weit, absolut, Adresse in Operand gegeben


    9A cp CALL ptr16: 32 Anruf weit, absolut, Adresse angegeben im Operanden


    FF / 3 CALL m16: 16 Ruf weit, absolut indirekt, Adresse in m16: 16


    FF / 3 CALL m16: 32 Anruf weit, absolut indirekt, Adresse in m16: 32 angegeben


    Antwort:


    Meine Lieblingsquelle ist Intel selbst: Intel® 64 und IA-32 Architekturen Software Entwickler Handbücher . Und im Gegensatz zu Versionen vorbei, sind alle Bände jetzt schön in einer einzigen (3044 Seite) PDF verpackt.


    Es sieht so aus, das der Abschnitt, der dir am meisten helfen wird 3.1.1.1 in Kapitel 3 von Band 2 ist (Seite 432 der letzten PDF-Ausgabe zur Zeit wo ich das schreibe).


    ----- Text ----


    3.1.1.1 Opcode-Spalte in der Anweisungsübersichtstabelle (Anleitung ohne VEX-Präfix)


    Die Spalte "Opcode" in der obigen Tabelle zeigt den für jede Form der Anweisung erzeugten Objektcode. Wenn möglich, werden Codes als hexadezimale Bytes in der gleichen Reihenfolge angegeben, in der sie im Speicher erscheinen. Definitionen von anderen als hexadezimalen Bytes sind wie folgt:


    • REX.W - Zeigt die Verwendung eines REX-Präfix an, das die Operandengröße oder die Instruktionssemantik beeinflusst. Die Bestellung des REX-Präfixes und anderer optionaler / obligatorischer Befehlspräfixe wird in Kapitel 2 beschrieben. Beachten Sie, dass REXprefixes, die Legacy-Befehle für das 64-Bit-Verhalten fördern, nicht explizit in der opcode-Spalte aufgeführt sind.


    • / digit - Eine Ziffer zwischen 0 und 7 zeigt an, dass das ModR / M-Byte des Befehls nur den Operanden r / m (registeror memory) verwendet. Das Reg-Feld enthält die Ziffer, die eine Erweiterung des Operations-Operationscodes bereitstellt.


    • / r - Zeigt an, dass das ModR / M-Byte des Befehls einen Registeroperanden und einen r / m-Operanden enthält.


    • cb, cw, cd, cp, co, ct - A 1-Byte (cb), 2-Byte (cw), 4-Byte (cd), 6-Byte (cp), 8-Byte (Co) oder 10 -byte (ct) Wert nach dem Opcode. Dieser Wert wird verwendet, um einen Code-Offset und eventuell einen neuen Wert für den Code-Segmentregister anzugeben.


    • ib, iw, id, io - Ein 1-Byte (ib), 2-Byte (iw), 4-Byte (id) oder 8-Byte (io) unmittelbarer Operand zu dem Befehl, der dem Operationscode ModR / M folgt Bytes oder Skalen-Index-Bytes. Der Opcode bestimmt, ob der Operand ein signierter Wert ist. Alle Wörter, Doppelwörter und Quadworte werden mit dem niederwertigen Byte zuerst gegeben.


    • + rb, + rw, + rd, + ro - Angabe der unteren 3 Bits des Opcode-Bytes wird verwendet, um den Registeroperanden ohne ModR / M-Byte zu codieren. Die Anweisung listet den entsprechenden Hexadezimalwert des Opcode-Bytes mit niedrigen 3 Bits als 000b auf. Im Nicht-64-Bit-Modus wird dem Hexadezimalwert des Opcode-Bytes ein Registercode von 0 bis 7 hinzugefügt. Im 64-Bit-Modus gibt das 4-Bit-Feld des REX.b- und Opcode-Feldes [2: 0] den Registeroperanden des Befehls an. "+ Ro" gilt nur im 64-Bit-Modus. Siehe Tabelle 3-1 für die Codes.


    • + i - Eine Zahl, die in Gleitkommabefehlen verwendet wird, wenn einer der Operanden ST (i) aus dem FPU-Registerstapel ist. Die Zahl i (die von 0 bis 7 reichen kann) wird dem Hexadezimalbyte hinzugefügt, das links vom Pluszeichen angegeben wird, um ein einziges Opcode-Byte zu bilden.


    3.1.1.3 Instruktionssäule in der Opcode-Übersichtstabelle


    Die Spalte "Instruction" gibt die Syntax der Befehlserklärung an, wie sie in einem ASM386-Programm erscheinen würde.


    Im Folgenden finden Sie eine Liste der Symbole, die zur Darstellung von Operanden in den Befehlsanweisungen verwendet werden:


    • rel8 - Eine relative Adresse im Bereich von 128 Bytes vor dem Ende des Befehls auf 127 Bytes nach dem Ende des Befehls.


    • rel16, rel32 - Eine relative Adresse innerhalb des gleichen Code-Segments wie die Anweisung zusammengesetzt. Das rel16-Symbol gilt für Anweisungen mit einem Operandengrößenattribut von 16 Bits; Das rel32-Symbol gilt für Anweisungen mit einem Operandengrößenattribut von 32 Bits.


    • ptr16: 16, ptr16: 32 - Ein weiter Zeiger, typischerweise zu einem Code-Segment, das sich von dem des Befehls unterscheidet. Die Notation 16:16 zeigt an, dass der Wert des Zeigers zwei Teile hat. Der Wert links vom Doppelpunkt ist ein 16-Bit-Selektor oder Wert, der für das Codesegmentregister bestimmt ist. Der Wert rechts entspricht dem Offset innerhalb des Zielsegments. Das Symbol ptr16: 16 wird verwendet, wenn das Operandengrößenattribut des Befehls 16 Bits beträgt; Das ptr16: 32-Symbol wird verwendet, wenn das Operandengrößenattribut 32 Bits beträgt.


    • r8 - Eines der Byte-Allzweckregister: AL, CL, DL, BL, AH, CH, DH, BH, BPL, SPL, DIL und SIL; Oder eines der Byte-Register (R8L - R15L) bei Verwendung von REX.R und 64-Bit-Modus.


    • r16 - Eines der Wort-Allzweckregister: AX, CX, DX, BX, SP, BP, SI, DI; Oder eines der Wortregister (R8-R15), das bei Verwendung des REX.R- und 64-Bit-Modus verfügbar ist.


    • r32 - Eines der Doppelwort-Register: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI; Oder eines der Doppelwortregister (R8D - R15D), das bei Verwendung von REX.R im 64-Bit-Modus verfügbar ist.


    • r64 - Eines der Quadwort-Allzweckregister: RAX, RBX, RCX, RDX, RDI, RSI, RBP, RSP, R8-R15. Diese sind bei Verwendung von REX.R und 64-Bit-Modus verfügbar.


    • imm8 - Ein sofortiger Bytewert. Das imm8-Symbol ist eine signierte Nummer zwischen -128 und +127 inklusive. Für Anweisungen, in denen imm8 mit einem Wort- oder Doppelwortoperanden kombiniert wird, wird der unmittelbare Wert signextended, um ein Wort oder ein Doppelwort zu bilden. Das obere Byte des Wortes wird mit dem obersten Bit des unmittelbaren Wertes gefüllt.


    • imm16 - Ein sofortiger Wortwert, der für Anweisungen verwendet wird, deren Operandengrößenattribut 16 Bits ist. Dies ist eine Zahl zwischen -32.768 und +32.767 inklusive.


    • imm32 - Ein sofortiger Doppelwortwert, der für Anweisungen verwendet wird, deren Operandengrößenattribut 32 Bits ist. Es erlaubt die Verwendung einer Zahl zwischen +2.147.483.647 und -2.147.483.648 einschließlich.


    • imm64 - Ein sofortiger Quadwortwert, der für Befehle verwendet wird, deren Operandengrößenattribut 64 Bits ist. Der Wert erlaubt die Verwendung einer Zahl zwischen +9.223.372.036.854.775.807 und -9.223.372.036.854.775.808 einschließlich.


    • r / m8 - Ein Byteoperand, der entweder der Inhalt eines Byte-Allzweckregisters (AL, CL, DL, BL, AH, CH, DH, BH, BPL, SPL, DIL und SIL) oder ein Byte aus dem Speicher ist . Byte-Register R8L - R15L sind mit REX.R im 64-Bit-Modus verfügbar.


    • r / m16 - Ein Wort-Allzweckregister oder Speicheroperand, der für Befehle verwendet wird, deren Operandengrößenattribut 16 Bits ist. Das Wort Allzweckregister sind: AX, CX, DX, BX, SP, BP, SI, DI. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird. Wortregister R8W - R15W sind mit REX.R im 64-Bit-Modus verfügbar.


    • r / m32 - Ein Doppelwort-Allzweckregister oder Speicheroperand, der für Befehle verwendet wird, deren Operanden-Attribut 32 Bits ist. Die Doppelwort-Register sind: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird. Doubleword-Register R8D - R15D sind verfügbar, wenn Sie REX.R im 64-Bit-Modus verwenden.


    • r / m64 - Ein quadword-Allzweckregister oder Speicheroperand, der für Befehle verwendet wird, deren Operandengrößenattribut bei der Verwendung von REX.W. 64 Bits ist. Quadword-Allzweckregister sind: RAX, RBX, RCX, RDX, RDI, RSI, RBP, RSP, R8-R15; Diese sind nur im 64-Bit-Modus verfügbar. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.
    Folgt Teil 2 von 2 ...

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

  • Und hier folgt der Teil 2 von 2 Teilen:
    Spoiler anzeigen


    • m - Ein 16-, 32- oder 64-Bit-Operand im Speicher.


    • m8 - Ein Byteoperand im Speicher, der üblicherweise als Variablen- oder Array-Name ausgedrückt wird, wies aber auf die DS: (E) SI oder ES: (E) DI-Register hin. Im 64-Bit-Modus wird auf die RSI- oder RDI-Register hingewiesen.


    • m16 - Ein Wortoperand im Speicher, der üblicherweise als Variablen- oder Array-Name ausgedrückt wird, wies aber auf die DS: (E) SI oder ES: (E) DI Register hin. Diese Nomenklatur wird nur mit den String-Anweisungen verwendet.


    • m32 - Ein Doppelwortoperand im Speicher, der üblicherweise als Variablen- oder Array-Name ausgedrückt wird, wies aber auf die DS: (E) SI- oder ES: (E) DI-Register hingewiesen. Diese Nomenklatur wird nur mit den String-Anweisungen verwendet.


    • m64 - Ein Speicher-Quadwort-Operand im Speicher.


    • m128 - Ein Speicher-Doppel-Quadwort-Operand im Speicher.


    • m16: 16, m16: 32 & m16: 64 - Ein Speicheroperand, der einen Fernzeiger enthält, der aus zwei Zahlen besteht. Die Zahl links vom Doppelpunkt entspricht dem Segmentselektor des Zeigers. Die Zahl rechts entspricht ihrem Offset.


    • m16 & 32, m16 & 16, m32 & 32, m16 & 64 - Ein Speicheroperand, bestehend aus Datenelementpaaren, deren Größen auf der linken und der rechten Seite des Markerzeichens angegeben sind. Alle Speicheradressierungsmodi sind erlaubt. Die Operatoren m16 & 16 und m32 & 32 werden von der BOUND-Anweisung verwendet, um einen Operanden bereitzustellen, der eine obere und eine untere Grenze für Array-Indizes enthält. Der Operator m16 & 32 wird von LIDT und LGDT verwendet, um ein Wort zu liefern, mit dem das Grenzfeld geladen werden soll, und ein Doppelwort, mit dem das Basisfeld der entsprechenden GDTR- und IDTR-Register geladen werden soll. Der Operator m16 & 64 wird von LIDT und LGDT im 64-Bit-Modus verwendet, um ein Wort zu liefern, mit dem das Grenzfeld geladen werden soll, und ein Quadwort, mit dem das Basisfeld der entsprechenden GDTR- und IDTR-Register geladen werden soll.


    • moffs8, moffs16, moffs32, moffs64 - Eine einfache Speichervariable (Speicheroffset ) von Typ-Byte, Wort oder Doppelwort, die von einigen Varianten der MOV-Anweisung verwendet wird. Die tatsächliche Adresse wird durch einen einfachen Versatz relativ zur Segmentbasis gegeben. In der Anweisung wird kein ModR / M-Byte verwendet. Die mit moffs angezeigte Zahl gibt ihre Größe an, die durch das Attribut der Adressgröße des Befehls bestimmt wird.


    • Sreg - Ein Segmentregister Die Segmentregister-Bitzuweisungen sind ES = 0, CS = 1, SS = 2, DS = 3, FS = 4 und GS = 5.


    • m32fp, m64fp, m80fp - Ein einpräziger, doppelpräziser und doppelter erweiterter Präzisions- (bzw.) Gleitkomma-Operand im Speicher. Diese Symbole bezeichnen Gleitkommawertwerte, die als Operanden für x87 FPU-Gleitkommabefehle verwendet werden.


    • m16int, m32int, m64int - Ein Wort, Doppelwort und Quadwort Integer (bzw.) Operand im Speicher. Diese Symbole bezeichnen ganze Zahlen, die als Operanden für x87 FPU Integer Anweisungen verwendet werden.


    • ST oder ST (0) - Das obere Element des FPU-Registerstapels.


    • ST (i) - Das i-te Element von der Oberseite des FPU-Registerstapels (i ← 0 bis 7).


    • mm - Ein MMX-Register. Die 64-Bit-MMX-Register sind: MM0 bis MM7.


    • mm / m32 - Die niederwertigen 32 Bits eines MMX-Registers oder ein 32-Bit-Speicheroperand. Die 64-Bit-MMX-Register sind: MM0 bis MM7. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.


    • mm / m64 - Ein MMX-Register oder ein 64-Bit- Speicheroperand . Die 64-Bit-MMX-Register sind: MM0 bis MM7. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.


    • xmm - Ein XMM-Register. Die 128-Bit-XMM-Register sind: XMM0 bis XMM7; XMM8 bis XMM15 sind mit REX.R im 64-Bit-Modus verfügbar.


    • xmm / m32- Ein XMM-Register oder ein 32-Bit-Speicheroperand. Die 128-Bit-XMM-Register sind XMM0 bis XMM7; XMM8 bis XMM15 sind mit REX.R im 64-Bit-Modus verfügbar. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.


    • xmm / m64 - Ein XMM-Register oder ein 64-Bit- Speicheroperand . Die 128-Bit-SIMD-Gleitkomma-Register sind XMM0 bis XMM7; XMM8 bis XMM15 sind mit REX.R im 64-Bit-Modus verfügbar. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.


    • xmm / m128 - Ein XMM-Register oder ein 128-Bit- Speicheroperand . Die 128-Bit-XMM-Register sind XMM0 bis XMM7; XMM8 bis XMM15 sind mit REX.R im 64-Bit-Modus verfügbar. Der Inhalt des Speichers befindet sich an der Adresse, die durch die effektive Adressberechnung bereitgestellt wird.


    • - Zeigt die implizite Verwendung des XMM0-Registers an. Wenn es Mehrdeutigkeit gibt, zeigt xmm1 den ersten Quelloperanden unter Verwendung eines XMM-Registers und xmm2 des zweiten Quelloperanden unter Verwendung eines XMM-Registers an. Einige Anweisungen verwenden das XMM0-Register als den dritten Quelloperanden, angegeben durch. Die Verwendung des dritten XMM-Registeroperanden ist implizit in der Befehlskodierung und beeinflusst die ModR / M-Codierung nicht.


    • ymm - Ein YMM-Register. Die 256-Bit-YMM-Register sind: YMM0 bis YMM7; YMM8 bis YMM15 sind im 64-Bit-Modus verfügbar.


    • m256 - Ein 32-Byte-Operand im Speicher. Diese Nomenklatur wird nur mit AVX-Anweisungen verwendet.


    • ymm / m256 - Ein YMM-Register oder 256-Bit- Speicheroperand .


    • - Zeigt die Verwendung des YMM0-Registers als implizites Argument an.


    • bnd - Ein 128-Bit-Schrankenregister. BND0 bis BND3.


    • mib - Ein Speicheroperand mit SIB-Adressierungsformular, bei dem das Indexregister bei der Adressberechnung nicht verwendet wird, wird die Skalierung ignoriert. Nur die Basis und die Verschiebung werden bei der effektiven Adressberechnung verwendet.


    • m512 - Ein 64-Byte-Operand im Speicher.


    • zmm / m512 - Ein ZMM-Register oder 512-Bit- Speicheroperand .


    • {k1} {z} - Ein Maskenregister, das als Befehlsschreibmaschine verwendet wird. Die 64-Bit-k-Register sind: k1 bis k7. Die Writemask-Spezifikation ist exklusiv über das EVEX-Präfix verfügbar. Die Maskierung kann entweder als Mergingmaske erfolgen, wo die alten Werte für maskierte Elemente oder als Nullpunktmaskierung erhalten bleiben. Die Art der Maskierung wird durch die Verwendung des EVEX.z-Bits bestimmt.


    • {k1} - Ohne {z}: ein Maskenregister, das als Befehls-Schreibmaschine für Anweisungen verwendet wird, die keine Nullabgleichung erlauben, aber die Verschmelzungsmaskierung unterstützen. Dies entspricht Anweisungen, die den Wert des aaa-Feldes von 0 unterscheiden müssen (zB sammeln) und speicherweise Anweisungen, die nur eine Verschmelzungsmaskierung erlauben.


    • k1 - Ein Maskenregister, das als regulärer Operand (Ziel oder Quelle) verwendet wird. Die 64-Bit-k-Register sind: k0 bis k7.


    • mV - Ein Vektorspeicheroperand; Die Operandengröße ist abhängig von der Anweisung.


    • vm32 {x, y, z} - Ein Vektor-Array von Speicheroperanden, die mit der VSIB-Speicheradressierung angegeben wurden. Das Array von Speicheradressen wird unter Verwendung eines gemeinsamen Basisregisters, eines konstanten Skalenfaktors und eines Vektorindexregisters mit einzelnen Elementen des 32-Bit-Indexwerts in einem XMM-Register (vm32x), einem YMM-Register (vm32y) oder einem ZMM-Register spezifiziert (Vm32z).


    • vm64 {x, y, z} - Ein Vektor-Array von Speicheroperanden, die mit der VSIB-Speicheradressierung angegeben wurden. Das Array von Speicheradressen wird unter Verwendung eines gemeinsamen Basisregisters, eines konstanten Skalenfaktors und eines Vektorindexregisters mit einzelnen Elementen des 64-Bit-Indexwerts in einem XMM-Register (vm64x), einem YMM-Register (vm64y) oder einem ZMM-Register spezifiziert (Vm64z).


    • zmm / m512 / m32bcst - Ein Operand, der ein ZMM-Register sein kann, ein 512-Bit- Speicherplatz oder ein 512-Bit-Vektor, der von einem 32-Bit- Speicherplatz geladen wird.


    • zmm / m512 / m64bcst - Ein Operand, der ein ZMM-Register sein kann, ein 512-Bit- Speicherplatz oder ein 512-Bit-Vektor, der von einem 64-Bit- Speicherplatz geladen wird.


    • - Zeigt die Verwendung des ZMM0-Registers als implizites Argument an.


    • {er} - Zeigt die Unterstützung der eingebetteten Rundungssteuerung an, die nur für das Registerregister der Anweisung gilt. Dies bedeutet auch die Unterstützung von SAE (Unterdrückung aller Ausnahmen).


    • {sae} - Zeigt Unterstützung für SAE an (Unterdrückung aller Ausnahmen). Dies wird für Anweisungen verwendet, die SAE unterstützen, aber keine eingebettete Rundungssteuerung unterstützen.


    • SRC1 - Zeigt den ersten Quelloperanden in der Befehlssyntax eines mit dem VEX / EVEX-Präfix codierten Befehls an und hat zwei oder mehr Quelloperanden.


    • SRC2 - Zeigt den zweiten Quelloperanden in der Befehlssyntax eines mit dem VEX / EVEX-Präfix codierten Befehls an und hat zwei oder mehr Quelloperanden.


    • SRC3 - Zeigt den dritten Quelloperanden in der Befehlssyntax eines mit dem VEX / EVEX-Präfix codierten Befehls an und hat drei Quelloperanden.


    • SRC - Die Quelle in einer Single-Source-Anweisung.


    • DST - das Ziel in einer Anweisung. Dieses Feld wird von reg_field codiert.


    P.S.: Eh ganz einfach, oder? :???:
  • Abt. Kommissar REX.W
    ===============
    Man braucht schon etwas kriminalistische Fähigkeiten, um dem Intel-Slang aud die Spur zu kommen. Prefixe, also Vorschalt-Bytes, verändern die Reaktion der x86-64 Maschine auf den folgenden OpCode. Dazu gibt es sogar ein Wiki! Lesenswert, wenn man in Nullen und Einsen mit Computern reden will. Ich glaube, ich warte auf Pfingsten, da soll ja der Geist der Mehrsprachigkeit auf uns hernieder kommen ...
    Gruss

    Spoiler anzeigen

    An x86-64 instruction may be at most 15 bytes in length. It consists of the following components in the given order, where the prefixes are at the least-significant (lowest) address in memory:


    Und hier die Antwort, was diese blöde REX.W bedeutet -

    The REX Byte Layout is as follows:
    7 0+---+---+---+---+---+---+---+---+| 0 1 0 0 | W | R | X | B |+---+---+---+---+---+---+---+---+W:When 1, a 64-bit operand size is used. Otherwise, when 0, the default operand size is used (which is 32-bit for most but not all instructions, see this table).
    R:
    This 1-bit value is an extension to the MODRM.reg field. See Registers. X:
    This 1-bit value is an extension to the SIB.index field. See 64-bit addressing. B:
    This 1-bit value is an extension to the MODRM.rm field or the SIB.base field. See 64-bit addressing


    P.S.: Ach ja, und hier erklären Hacker auf deutsch, wie so ein PC-Werkel eigentlich funktioniert...
    PPS: Scio nescio oder Dunning-Kruger?

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

  • Abt. Und ich dachte immer ...
    ==================

    z.B. dass ASCII, ANSI und UTF-8 Synonyme wären. Pfffffff!
    Spoiler anzeigen

    • "Unicode" isn't an encoding, although unfortunately, a lot of documentation imprecisely uses it to refer to whichever Unicode encoding that particular system uses by default. On Windows and Java, this often means UTF-16; in many other places, it means UTF-8. Properly, Unicode refers to the abstract character set itself, not to any particular encoding.
    • UTF-16: 2 bytes per "code unit". This is the native format of strings in .NET, and generally in Windows and Java. Values outside the Basic Multilingual Plane (BMP) are encoded as surrogate pairs. (These are relatively rarely used - which is a good job, as very few developers get them right, I suspect. I very much doubt that I do.)
    • UTF-8: Variable length encoding, 1-4 bytes per code point. ASCII values are encoded as ASCII using 1 byte.
    • UTF-7: Usually used for mail encoding. Chances are if you think you need it and you're not doing mail, you're wrong. (That's just my experience of people posting in newsgroups etc - outside mail, it's really not widely used at all.)
    • UTF-32: Fixed width encoding using 4 bytes per code point. This isn't very efficient, but makes life easier outside the BMP. I have a .NET Utf32String class as part of my MiscUtil library, should you ever want it. (It's not been very thoroughly tested, mind you.)
    • ASCII: Single byte encoding only using the bottom 7 bits. (Unicode code points 0-127.) No accents etc.
    • ANSI: There's no one fixed ANSI encoding - there are lots of them. Usually when people say "ANSI" they mean "the default locale/codepage for my system" which is obtained via Encoding.Default, and is often Windows-1252 but can be other locales.
    P.S.: Quellenlink
  • Abt. Ziffern-Selfies natürlicher Zahlen
    ========================
    Jede beliebige natürliche Zahl kann durch mehrfache Kombination der immer gleichen einzelnen Ziffer mittels geeigneter Grundrechenarten dargestellt werden. Trivial wäre folgender "Beweis":

    0 = a−a; 1 = a/a; 2 = (a+a)/a; 3 = (a+a+a)/a; ...

    Zahlentheoretiker haben aber jene Kombinationen gesucht, die die jeweils kürzeste Darstellungsform ermöglichen, was bei ein-, zwei- und dreistelligen Zahlen zu diesem epochalen, 55-seitigen Werk führte.

    Bei einer ähnlich verschrobenen Aufgabe, nämlich bis zu fünfstellige Zahlen durch eine aufsteigende oder absteigende Folge von (durch Grundrechnungsarten und Klammern) verbundener Ziffern von 1 bis 9 darzustellen, stiess man auf das 10958-Problem: Für diese Zahl wurde als erste eine solche Darstellungsmöglichkeit bisher nicht gefunden (... wobei bis dato auch nur bis 11111 gesucht wurde, dieses Werk hat dann 166 engbedruckte Seiten).
    Gruss

    P.S.: Gerade erfahre ich, es gibt bereits erste Ergebnisse zum 10958-Problem!

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

  • Abt. Befehle geben braucht Regeln
    ======================
    ... insb. wenn es um Befehle an Maschinen geht. Fa. Intel scheint da Meister in angewandtem Verwirrspiel um die korrekte Reihenfolge innerhalb von Befehlen; das führt dazu, daß Befehlssequenzen inklusive Ziel- und Quellenangaben insgesamt bis zu 15 Byte lang sein können.

    Die Reihenfolge von Vorschaltbytes, Escapecode, OpCode, Modifierbyte, Sekundär-Informationsbyte und Adressangaben bzw. Zahlenangaben ist verwirrend und sieht schlimmstenfalls so aus:

    (Niedere Speicheradresse)
    1. Legacy Prefixes der Gruppen 1, 2 oder 3 (Option)
    2. REX (bei 64-bit-Registeransprache, dann ggf. auch VEX und/oder AVEX)
    3. Der OpCode selbst mit 1, 2 oder 3 Byte
    4. Ein ModRM-Byte (2bit mod, 3bit reg, 3bit rm) wenn OpCode es fordert
    5. SIB (secondary information byte) falls OpCode es fordert
    6. Adressenversatz (1, 2 oder 4 Byte)
    7. Sofortwerte (Zahlenangaben, 1, 2 oder 4 Byte lang)
    (Hohe Speicheradresse)

    Gruss

    P.S.: Wer glaubt, den genannten Zusatzbytes (bzw. Teilfeldern darin) stets gleichartige Funktionen beimessen zu können, der wird ziemlich oft enttäuscht werden. Ein Wunder, dass sowas funktioniert...