Fix build breakage on Sparc.

[cln.git] / src / base / digitseq / cl_asm_m68k_.cc

diff --git a/src/base/digitseq/cl_asm_m68k_.cc b/src/base/digitseq/cl_asm_m68k_.cc
index 50a0a9b6465ff70763d2023ef9c390c1f39a44f8..efb81c8b68e084eaca1a5b4be021e22b3cec428c 100644 (file)
--- a/src/base/digitseq/cl_asm_m68k_.cc
+++ b/src/base/digitseq/cl_asm_m68k_.cc
@@ -2,11 +2,11 @@
 // Prozessor: 680x0 mit x>=2
 // Assembler-Syntax: meist "$" streichen, auf A/UX "$" durch "%" ersetzen
 // Compiler: CC oder GNU-C auf SUN3 oder AMIGA oder A/UX
-// Parameter-Übergabe:
-//   auf dem Stack: sp@(4), sp@(8), ... (.W-Größen belegen 4 Byte!),
-//   Rückgabewert in d0.
+// Parameter-Übergabe:
+//   auf dem Stack: sp@(4), sp@(8), ... (.W-Größen belegen 4 Byte!),
+//   Rückgabewert in d0.
 // Register a0-a1,d0-d1 frei verwendbar,
-// Register a2-a4,d2-d7 müssen gerettet werden.
+// Register a2-a4,d2-d7 müssen gerettet werden.
 // Einstellungen: intCsize=16, intDsize=32.
 
   #ifdef ASM_UNDERSCORE
@@ -19,7 +19,7 @@
     #define C(entrypoint) entrypoint
   #endif
 
-  // Befehl, der das X- und das C-Bit löscht (und evtl. d1 modifiziert):
+  // Befehl, der das X- und das C-Bit löscht (und evtl. d1 modifiziert):
   #if defined(sun)
     // SUN-Assembler
     #define clrx   subw $d1,$d1
@@ -90,7 +90,7 @@ C(mulu32_:) | Input in d0,d1, Output in d0,mulu32_high
 #ifndef __GNUC__ /* mit GNU-C machen wir divu_6432_3232() als Macro, der inline dividiert */
            .globl C(divu_6432_3232_)
 | extern struct { uint32 q; uint32 r; } divu_6432_3232_ (uint32 xhi, uint32 xlo, uint32 y);
-| x = 2^32*xhi+xlo = q*y+r schreiben. Sei bekannt, daß 0 <= x < 2^32*y .
+| x = 2^32*xhi+xlo = q*y+r schreiben. Sei bekannt, daß 0 <= x < 2^32*y .
            DECLARE_FUNCTION(divu_6432_3232_)
 C(divu_6432_3232_:) | Input in d1,d0,d2, Output in d0,divu_32_rest
            movel $sp@(4),$d1
@@ -202,7 +202,7 @@ C(test_loop_down:) | Input in a0,d0.W, Output in d0.W=d0.L
 
 | extern void or_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(or_loop_up)
-C(or_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(or_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -216,7 +216,7 @@ C(or_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void xor_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(xor_loop_up)
-C(xor_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(xor_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -230,7 +230,7 @@ C(xor_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void and_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(and_loop_up)
-C(and_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(and_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -242,7 +242,7 @@ C(and_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void eqv_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(eqv_loop_up)
-C(eqv_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(eqv_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -255,7 +255,7 @@ C(eqv_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void nand_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(nand_loop_up)
-C(nand_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(nand_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -268,7 +268,7 @@ C(nand_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void nor_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(nor_loop_up)
-C(nor_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(nor_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -281,7 +281,7 @@ C(nor_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void andc2_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(andc2_loop_up)
-C(andc2_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(andc2_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -294,7 +294,7 @@ C(andc2_loop_up:) | Input in a0,a1,d0.W, ver
 
 | extern void orc2_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(orc2_loop_up)
-C(orc2_loop_up:) | Input in a0,a1,d0.W, verändert d1
+C(orc2_loop_up:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -317,7 +317,7 @@ C(not_loop_up:) | Input in a0,d0.W
 
 | extern boolean and_test_loop_up (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(and_test_loop_up)
-C(and_test_loop_up:) | Input in a0,a1,d0.W, verändert d1, Output in d0.W=d0.L
+C(and_test_loop_up:) | Input in a0,a1,d0.W, verändert d1, Output in d0.W=d0.L
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -355,20 +355,20 @@ C(compare_loop_up:) | Input in a0,a1,d0.W, Output in d0.W=d0.L
 
 | extern uintD add_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
            DECLARE_FUNCTION(add_loop_down)
-C(add_loop_down:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
+C(add_loop_down:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
            movel $sp@(8+12),$a2
            movew $sp@(8+16+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@-,$d1
              movel $a1@-,$d2
              addxl $d2,$d1
              movel $d1,$a2@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
@@ -378,11 +378,11 @@ C(addto_loop_down:) | Input in a0,a1,d0.W, Output in d0
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       addxl $a0@-,$a1@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD inc_loop_down (uintD* ptr, uintC count);
@@ -391,35 +391,35 @@ C(inc_loop_down:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            dbra $d0,1f          | simuliere gesetzten Carry
-           moveq #-1,$d0     | d0.L=-1 für Übertrag
+           moveq #-1,$d0     | d0.L=-1 für Übertrag
            rts
     1:       addql #1,$a0@-
              dbcc $d0,1b
-           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 für Übertrag
+           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 für Übertrag
            rts
 
 | extern uintD sub_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
            DECLARE_FUNCTION(sub_loop_down)
-C(sub_loop_down:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
+C(sub_loop_down:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
            movel $sp@(8+12),$a2
            movew $sp@(8+16+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@-,$d1
              movel $a1@-,$d2
              subxl $d2,$d1
              movel $d1,$a2@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
 | extern uintD subx_loop_down (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count, uintD carry);
            DECLARE_FUNCTION(subx_loop_down)
-C(subx_loop_down:) | Input in a0,a1,a2,d0.W,d1, verändert d2, Output in d0
+C(subx_loop_down:) | Input in a0,a1,a2,d0.W,d1, verändert d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
@@ -433,7 +433,7 @@ C(subx_loop_down:) | Input in a0,a1,a2,d0.W,d1, ver
              subxl $d2,$d1
              movel $d1,$a2@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
@@ -443,11 +443,11 @@ C(subfrom_loop_down:) | Input in a0,a1,d0.W, Output in d0
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       subxl $a0@-,$a1@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD dec_loop_down (uintD* ptr, uintC count);
@@ -456,11 +456,11 @@ C(dec_loop_down:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            dbra $d0,1f          | simuliere gesetzten Carry
-           moveq #-1,$d0     | d0.L=-1 als Übertrag
+           moveq #-1,$d0     | d0.L=-1 als Übertrag
            rts
     1:       subql #1,$a0@-
              dbcc $d0,1b       | kein Carry -> Schleife abbrechen
-           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 als Übertrag
+           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 als Übertrag
            rts
 
 | extern uintD neg_loop_down (uintD* ptr, uintC count);
@@ -468,11 +468,11 @@ C(dec_loop_down:) | Input in a0,d0.W, Output in d0
 C(neg_loop_down:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       negxl $a0@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shift1left_loop_down (uintD* ptr, uintC count);
@@ -480,12 +480,12 @@ C(neg_loop_down:) | Input in a0,d0.W, Output in d0
 C(shift1left_loop_down:) | Input in a0,d0.W, Output in d0.L
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       roxlw $a0@-     | Digit a0@- um 1 Bit links schieben, X-Bit als Buffer
              roxlw $a0@-
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shiftleft_loop_down (uintD* ptr, uintC count, uintC i, uintD carry);
@@ -500,15 +500,15 @@ C(shiftleft_loop_down:) | Input in a0,d0.W,d1.W,d2, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@-,$d3  | d3.L = neues Digit
              movel $d3,$d4
              lsll $d1,$d4      | um i Bits nach links schieben
-             orl $d2,$d4       | mit vorigem Übertrag kombinieren
+             orl $d2,$d4       | mit vorigem Übertrag kombinieren
              movel $d4,$a0@   | 32 Bits ablegen
              movel $d3,$d2
-             lsrl $d5,$d2      | neuen Übertrag bilden
+             lsrl $d5,$d2      | neuen Übertrag bilden
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -523,16 +523,16 @@ C(shiftleft_loop_down:) | Input in a0,d0.W,d1.W,d2, Output in d0
            lsll $d1,$d5
            subql #1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^i-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@-,$d3  | d3.L = neues Digit
              roll $d1,$d3      | um i Bits links rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere i Bits in d3
              eorl $d3,$d4      | obere 32-i Bits in d4
-             orl $d2,$d4       | mit vorigem übertrag kombinieren
+             orl $d2,$d4       | mit vorigem übertrag kombinieren
              movel $d4,$a0@   | 32 Bits ablegen
-             movel $d3,$d2     | neuer Übertrag
+             movel $d3,$d2     | neuer Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -552,15 +552,15 @@ C(shiftleftcopy_loop_down:) | Input in a0,a1,d0.W,d1.W, Output in d0
            subw $d1,$d5
            clrl $d2
            | a0 = sourceptr, a1 = destptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@-,$d3  | d3.L = neues Digit
              movel $d3,$d4
              lsll $d1,$d4      | um i Bits nach links schieben
-             orl $d2,$d4       | mit vorigem Übertrag kombinieren
+             orl $d2,$d4       | mit vorigem Übertrag kombinieren
              movel $d4,$a1@-  | 32 Bits ablegen
              movel $d3,$d2
-             lsrl $d5,$d2      | neuen Übertrag bilden
+             lsrl $d5,$d2      | neuen Übertrag bilden
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -575,16 +575,16 @@ C(shiftleftcopy_loop_down:) | Input in a0,a1,d0.W,d1.W, Output in d0
            lsll $d1,$d5
            subql #1,$d5
            | a0 = sourceptr, a1 = destptr, d0.W = count, d1.W = i, d5.L = 2^i-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@-,$d3  | d3.L = neues Digit
              roll $d1,$d3      | um i Bits links rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere i Bits in d3
              eorl $d3,$d4      | obere 32-i Bits in d4
-             orl $d2,$d4       | mit vorigem übertrag kombinieren
+             orl $d2,$d4       | mit vorigem übertrag kombinieren
              movel $d4,$a1@-  | 32 Bits ablegen
-             movel $d3,$d2     | neuer Übertrag
+             movel $d3,$d2     | neuer Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -597,12 +597,12 @@ C(shift1right_loop_up:) | Input in a0,d0.W,d1, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            movel $sp@(12),$d1
-           roxrl #1,$d1       | X-Bit löschen oder setzen, je nach d1
+           roxrl #1,$d1       | X-Bit löschen oder setzen, je nach d1
            bras 2f
     1:       roxrw $a0@+     | Digit a0@+ um 1 Bit rechts schieben, X-Bit als Buffer
              roxrw $a0@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shiftright_loop_up (uintD* ptr, uintC count, uintC i);
@@ -616,19 +616,19 @@ C(shiftright_loop_up:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            clrl $d2
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@,$d3   | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
              movel $d3,$a0@+  | ablegen
              lsll $d5,$d4      | um (32-i) Bits links geschoben
-             movel $d4,$d2     | liefert neuen Übertrag
+             movel $d4,$d2     | liefert neuen Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -641,19 +641,19 @@ C(shiftright_loop_up:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #-1,$d5
            lsrl $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            clrl $d2
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@,$d3   | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
              movel $d3,$a0@+  | ablegen
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -672,22 +672,22 @@ C(shiftrightsigned_loop_up:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            subqw #1,$d0
            movel $a0@,$d3     | erstes Digit
            movel $d3,$d4
            asrl $d1,$d3        | um i Bits rechts schieben
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@,$d3   | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
     2:       movel $d3,$a0@+  | ablegen
              lsll $d5,$d4      | um (32-i) Bits links geschoben
-             movel $d4,$d2     | liefert neuen Übertrag
+             movel $d4,$d2     | liefert neuen Übertrag
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -700,7 +700,7 @@ C(shiftrightsigned_loop_up:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #-1,$d5
            lsrl $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            subqw #1,$d0
            movel $a0@,$d3     | erstes Digit
            movel $d3,$d4
@@ -710,16 +710,16 @@ C(shiftrightsigned_loop_up:) | Input in a0,d0.W,d1.W, Output in d0
            andl $d4,$d2        | obere 32-i Bits
            asrl $d1,$d3        | erstes Digit um i Bits rechts shiften
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@,$d3   | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
     2:       movel $d3,$a0@+  | ablegen
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -740,18 +740,18 @@ C(shiftrightcopy_loop_up:) | Input in a0,a1,d0.W,d1.W,d2, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
-    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@+,$d3  | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
              movel $d3,$a1@+  | ablegen
              movel $d4,$d2
-    2:       lsll $d5,$d2      | um (32-i) Bits links geschoben, gibt neuen Übertrag
+    2:       lsll $d5,$d2      | um (32-i) Bits links geschoben, gibt neuen Übertrag
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -767,18 +767,18 @@ C(shiftrightcopy_loop_up:) | Input in a0,a1,d0.W,d1.W,d2, Output in d0
            lsrl $d1,$d5
            rorl $d1,$d2
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
-    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@+,$d3  | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
              movel $d3,$a1@+  | ablegen
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -794,9 +794,9 @@ C(mulusmall_loop_down:) | Input in d0,a0,d1.W,d2, Output in d0
            movel $sp@(12+8),$a0
            movew $sp@(12+12+2),$d1
            movel $sp@(12+16),$d2
-           addw #0,$d1        | X-Bit löschen
+           addw #0,$d1        | X-Bit löschen
            bras 2f
-    1:       movel $a0@-,$d3  | nächstes Digit
+    1:       movel $a0@-,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              movel $d3,$a0@   | Low-Digit ablegen
@@ -816,9 +816,9 @@ C(mulu_loop_down:) | Input in d0,a0,a1,d1.W
            movel $sp@(12+8),$a0
            movel $sp@(12+12),$a1
            movew $sp@(12+16+2),$d1
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@-,$d3  | nächstes Digit
+    1:       movel $a0@-,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              movel $d3,$a1@-  | Low-Digit ablegen
@@ -838,7 +838,7 @@ C(mulu_loop_down:) | Input in d0,a0,a1,d1.W
            clrl $d5           | 0
            clrl $d2           | carry
            bras 2f
-    1:       movel $a0@-,$d3  | nächstes Digit
+    1:       movel $a0@-,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addl $d2,$d3      | und bisherigen Carry addieren
              addxl $d5,$d4
@@ -859,13 +859,13 @@ C(muluadd_loop_down:) | Input in d0,a0,a1,d1.W, Output in d0
            movel $sp@(16+12),$a1
            movew $sp@(16+16+2),$d1
            clrl $d5           | 0
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@-,$d3  | nächstes Digit
+    1:       movel $a0@-,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              addxl $d5,$d4
-             addl $d3,$a1@-   | Low-Digit zum dest-Digit addieren, X als Übertrag
+             addl $d3,$a1@-   | Low-Digit zum dest-Digit addieren, X als Übertrag
              movel $d4,$d2     | High-Digit gibt neuen Carry
     2:       dbra $d1,1b
            addxl $d5,$d2       | letztes X-Bit addieren
@@ -882,13 +882,13 @@ C(mulusub_loop_down:) | Input in d0,a0,a1,d1.W, Output in d0
            movel $sp@(16+12),$a1
            movew $sp@(16+16+2),$d1
            clrl $d5           | 0
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@-,$d3  | nächstes Digit
+    1:       movel $a0@-,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              addxl $d5,$d4
-             subl $d3,$a1@-   | Low-Digit vom dest-Digit subtrahieren, X als Übertrag
+             subl $d3,$a1@-   | Low-Digit vom dest-Digit subtrahieren, X als Übertrag
              movel $d4,$d2     | High-Digit gibt neuen Carry
     2:       dbra $d1,1b
            clrl $d0
@@ -905,7 +905,7 @@ C(divu_loop_up:) | Input in d0,a0,d1.W, Output in d0
            movew $sp@(8+12+2),$d1
            clrl $d2           | Rest := 0
            bras 2f
-    1:       movel $a0@,$d3   | nächst-niedriges Digit
+    1:       movel $a0@,$d3   | nächst-niedriges Digit
              divul $d0,$d2:$d3  | mit Rest kombinieren und durch digit dividieren
              movel $d3,$a0@+  | Quotient ablegen, Rest in d2
     2:       dbra $d1,1b
@@ -923,7 +923,7 @@ C(divucopy_loop_up:) | Input in d0,a0,a1,d1.W, Output in d0
            movew $sp@(8+16+2),$d1
            clrl $d2           | Rest := 0
            bras 2f
-    1:       movel $a0@+,$d3  | nächst-niedriges Digit
+    1:       movel $a0@+,$d3  | nächst-niedriges Digit
              divul $d0,$d2:$d3  | mit Rest kombinieren und durch digit dividieren
              movel $d3,$a1@+  | Quotient ablegen, Rest in d2
     2:       dbra $d1,1b
@@ -937,7 +937,7 @@ C(divucopy_loop_up:) | Input in d0,a0,a1,d1.W, Output in d0
 
 | extern void or_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(or_loop_down)
-C(or_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(or_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -949,7 +949,7 @@ C(or_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void xor_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(xor_loop_down)
-C(xor_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(xor_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -961,7 +961,7 @@ C(xor_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void and_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(and_loop_down)
-C(and_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(and_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -973,7 +973,7 @@ C(and_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void eqv_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(eqv_loop_down)
-C(eqv_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(eqv_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -986,7 +986,7 @@ C(eqv_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void nand_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(nand_loop_down)
-C(nand_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(nand_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -999,7 +999,7 @@ C(nand_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void nor_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(nor_loop_down)
-C(nor_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(nor_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -1012,7 +1012,7 @@ C(nor_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void andc2_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(andc2_loop_down)
-C(andc2_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(andc2_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -1025,7 +1025,7 @@ C(andc2_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern void orc2_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(orc2_loop_down)
-C(orc2_loop_down:) | Input in a0,a1,d0.W, verändert d1
+C(orc2_loop_down:) | Input in a0,a1,d0.W, verändert d1
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -1048,7 +1048,7 @@ C(not_loop_down:) | Input in a0,d0.W
 
 | extern boolean and_test_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(and_test_loop_down)
-C(and_test_loop_down:) | Input in a0,a1,d0.W, verändert d1, Output in d0.W=d0.L
+C(and_test_loop_down:) | Input in a0,a1,d0.W, verändert d1, Output in d0.W=d0.L
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
@@ -1064,7 +1064,7 @@ C(and_test_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern cl_signean compare_loop_down (uintD* xptr, uintD* yptr, uintC count);
            DECLARE_FUNCTION(compare_loop_down)
-C(compare_loop_down:) | Input in a0,a1,d0.W, verändert d1,d2, Output in d0.W=d0.L
+C(compare_loop_down:) | Input in a0,a1,d0.W, verändert d1,d2, Output in d0.W=d0.L
            movel $d2,$sp@-
            movel $sp@(4+4),$a0
            movel $sp@(4+8),$a1
@@ -1088,38 +1088,38 @@ C(compare_loop_down:) | Input in a0,a1,d0.W, ver
 
 | extern uintD add_loop_up (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
            DECLARE_FUNCTION(add_loop_up)
-C(add_loop_up:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
+C(add_loop_up:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
            movel $sp@(8+12),$a2
            movew $sp@(8+16+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@+,$d1
              movel $a1@+,$d2
              addxl $d2,$d1
              movel $d1,$a2@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
 | extern uintD addto_loop_up (uintD* sourceptr, uintD* destptr, uintC count);
            DECLARE_FUNCTION(addto_loop_up)
-C(addto_loop_up:) | Input in a0,a1,d0.W, verändert d1,d2, Output in d0
+C(addto_loop_up:) | Input in a0,a1,d0.W, verändert d1,d2, Output in d0
            movel $d2,$sp@-
            movel $sp@(4+4),$a0
            movel $sp@(4+8),$a1
            movew $sp@(4+12+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@+,$d1
              movel $a1@,$d2
              addxl $d1,$d2
              movel $d2,$a1@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            movel $sp@+,$d2
            rts
 
@@ -1129,35 +1129,35 @@ C(inc_loop_up:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            dbra $d0,1f          | simuliere gesetzten Carry
-           moveq #-1,$d0     | d0.L=-1 für Übertrag
+           moveq #-1,$d0     | d0.L=-1 für Übertrag
            rts
     1:       addql #1,$a0@+
              dbcc $d0,1b
-           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 für Übertrag
+           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 für Übertrag
            rts
 
 | extern uintD sub_loop_up (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count);
            DECLARE_FUNCTION(sub_loop_up)
-C(sub_loop_up:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
+C(sub_loop_up:) | Input in a0,a1,a2,d0.W, verändert d1,d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
            movel $sp@(8+12),$a2
            movew $sp@(8+16+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@+,$d1
              movel $a1@+,$d2
              subxl $d2,$d1
              movel $d1,$a2@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
 | extern uintD subx_loop_up (uintD* sourceptr1, uintD* sourceptr2, uintD* destptr, uintC count, uintD carry);
            DECLARE_FUNCTION(subx_loop_up)
-C(subx_loop_up:) | Input in a0,a1,a2,d0.W,d1, verändert d2, Output in d0
+C(subx_loop_up:) | Input in a0,a1,a2,d0.W,d1, verändert d2, Output in d0
            moveml $a2/$d2,$sp@-
            movel $sp@(8+4),$a0
            movel $sp@(8+8),$a1
@@ -1171,7 +1171,7 @@ C(subx_loop_up:) | Input in a0,a1,a2,d0.W,d1, ver
              subxl $d2,$d1
              movel $d1,$a2@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            moveml $sp@+,$a2/$d2
            rts
 
@@ -1181,14 +1181,14 @@ C(subfrom_loop_up:) | Input in a0,a1,d0.W, Output in d0
            movel $sp@(4),$a0
            movel $sp@(8),$a1
            movew $sp@(12+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@+,$d1
              movel $a1@,$d2
              subxl $d1,$d2
              movel $d2,$a1@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD dec_loop_up (uintD* ptr, uintC count);
@@ -1197,11 +1197,11 @@ C(dec_loop_up:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            dbra $d0,1f          | simuliere gesetzten Carry
-           moveq #-1,$d0     | d0.L=-1 als Übertrag
+           moveq #-1,$d0     | d0.L=-1 als Übertrag
            rts
     1:       subql #1,$a0@+
              dbcc $d0,1b       | kein Carry -> Schleife abbrechen
-           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 als Übertrag
+           subxl $d0,$d0       | kein Carry -> d0.L=0, sonst d0.L=-1 als Übertrag
            rts
 
 | extern uintD neg_loop_up (uintD* ptr, uintC count);
@@ -1209,25 +1209,25 @@ C(dec_loop_up:) | Input in a0,d0.W, Output in d0
 C(neg_loop_up:) | Input in a0,d0.W, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       negxl $a0@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shift1left_loop_up (uintD* ptr, uintC count);
            DECLARE_FUNCTION(shift1left_loop_up)
-C(shift1left_loop_up:) | Input in a0,d0.W, verändert d1, Output in d0.L
+C(shift1left_loop_up:) | Input in a0,d0.W, verändert d1, Output in d0.L
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
-           clrx   | X-Bit löschen
+           clrx   | X-Bit löschen
            bras 2f
     1:       movel $a0@,$d1
              roxll #1,$d1
              movel $d1,$a0@+
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shiftleft_loop_up (uintD* ptr, uintC count, uintC i, uintD carry);
@@ -1242,15 +1242,15 @@ C(shiftleft_loop_up:) | Input in a0,d0.W,d1.W,d2, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@,$d3  | d3.L = neues Digit
              movel $d3,$d4
              lsll $d1,$d4      | um i Bits nach links schieben
-             orl $d2,$d4       | mit vorigem Übertrag kombinieren
+             orl $d2,$d4       | mit vorigem Übertrag kombinieren
              movel $d4,$a0@+   | 32 Bits ablegen
              movel $d3,$d2
-             lsrl $d5,$d2      | neuen Übertrag bilden
+             lsrl $d5,$d2      | neuen Übertrag bilden
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1265,16 +1265,16 @@ C(shiftleft_loop_up:) | Input in a0,d0.W,d1.W,d2, Output in d0
            lsll $d1,$d5
            subql #1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^i-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@,$d3  | d3.L = neues Digit
              roll $d1,$d3      | um i Bits links rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere i Bits in d3
              eorl $d3,$d4      | obere 32-i Bits in d4
-             orl $d2,$d4       | mit vorigem übertrag kombinieren
+             orl $d2,$d4       | mit vorigem übertrag kombinieren
              movel $d4,$a0@+   | 32 Bits ablegen
-             movel $d3,$d2     | neuer Übertrag
+             movel $d3,$d2     | neuer Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1296,15 +1296,15 @@ C(shiftleftcopy_loop_up:) | Input in a0,a1,d0.W,d1.W, Output in d0
            subw $d1,$d5
            clrl $d2
            | a0 = sourceptr, a1 = destptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@+,$d3  | d3.L = neues Digit
              movel $d3,$d4
              lsll $d1,$d4      | um i Bits nach links schieben
-             orl $d2,$d4       | mit vorigem Übertrag kombinieren
+             orl $d2,$d4       | mit vorigem Übertrag kombinieren
              movel $d4,$a1@+  | 32 Bits ablegen
              movel $d3,$d2
-             lsrl $d5,$d2      | neuen Übertrag bilden
+             lsrl $d5,$d2      | neuen Übertrag bilden
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1319,16 +1319,16 @@ C(shiftleftcopy_loop_up:) | Input in a0,a1,d0.W,d1.W, Output in d0
            lsll $d1,$d5
            subql #1,$d5
            | a0 = sourceptr, a1 = destptr, d0.W = count, d1.W = i, d5.L = 2^i-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a0@+,$d3  | d3.L = neues Digit
              roll $d1,$d3      | um i Bits links rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere i Bits in d3
              eorl $d3,$d4      | obere 32-i Bits in d4
-             orl $d2,$d4       | mit vorigem übertrag kombinieren
+             orl $d2,$d4       | mit vorigem übertrag kombinieren
              movel $d4,$a1@+  | 32 Bits ablegen
-             movel $d3,$d2     | neuer Übertrag
+             movel $d3,$d2     | neuer Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1343,13 +1343,13 @@ C(shift1right_loop_down:) | Input in a0,d0.W,d1, Output in d0
            movel $sp@(4),$a0
            movew $sp@(8+2),$d0
            movel $sp@(12),$d1
-           roxrl #1,$d1       | X-Bit löschen oder setzen, je nach d1
+           roxrl #1,$d1       | X-Bit löschen oder setzen, je nach d1
            bras 2f
     1:       movel $a0@-,$d1
              roxrl #1,$d1
              movel $d1,$a0@
     2:       dbra $d0,1b
-           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
+           subxl $d0,$d0       | -1 falls X gesetzt, 0 falls X gelöscht
            rts
 
 | extern uintD shiftright_loop_down (uintD* ptr, uintC count, uintC i);
@@ -1363,19 +1363,19 @@ C(shiftright_loop_down:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            clrl $d2
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3   | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
              movel $d3,$a0@  | ablegen
              lsll $d5,$d4      | um (32-i) Bits links geschoben
-             movel $d4,$d2     | liefert neuen Übertrag
+             movel $d4,$d2     | liefert neuen Übertrag
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1388,19 +1388,19 @@ C(shiftright_loop_down:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #-1,$d5
            lsrl $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            clrl $d2
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3   | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
              movel $d3,$a0@  | ablegen
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -1419,22 +1419,22 @@ C(shiftrightsigned_loop_down:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            subqw #1,$d0
            movel $a0@-,$d3     | erstes Digit
            movel $d3,$d4
            asrl $d1,$d3        | um i Bits rechts schieben
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3   | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
     2:       movel $d3,$a0@  | ablegen
              lsll $d5,$d4      | um (32-i) Bits links geschoben
-             movel $d4,$d2     | liefert neuen Übertrag
+             movel $d4,$d2     | liefert neuen Übertrag
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1447,7 +1447,7 @@ C(shiftrightsigned_loop_down:) | Input in a0,d0.W,d1.W, Output in d0
            moveq #-1,$d5
            lsrl $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            subqw #1,$d0
            movel $a0@-,$d3     | erstes Digit
            movel $d3,$d4
@@ -1457,16 +1457,16 @@ C(shiftrightsigned_loop_down:) | Input in a0,d0.W,d1.W, Output in d0
            andl $d4,$d2        | obere 32-i Bits
            asrl $d1,$d3        | erstes Digit um i Bits rechts shiften
            bras 2f
-    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1,
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3   | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
     2:       movel $d3,$a0@  | ablegen
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -1487,18 +1487,18 @@ C(shiftrightcopy_loop_down:) | Input in a0,a1,d0.W,d1.W,d2, Output in d0
            moveq #32,$d5
            subw $d1,$d5
            | a0 = ptr, d0.W = count, d1.W = i, d5.W = 32-i
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
-    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.W = 32-i
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3  | neue Daten
              movel $d3,$d4
              lsrl $d1,$d3      | um i Bits rechts schieben
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
              movel $d3,$a1@-  | ablegen
              movel $d4,$d2
-    2:       lsll $d5,$d2      | um (32-i) Bits links geschoben, gibt neuen Übertrag
+    2:       lsll $d5,$d2      | um (32-i) Bits links geschoben, gibt neuen Übertrag
              dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
            moveml $sp@+,$d2-$d5
@@ -1514,18 +1514,18 @@ C(shiftrightcopy_loop_down:) | Input in a0,a1,d0.W,d1.W,d2, Output in d0
            lsrl $d1,$d5
            rorl $d1,$d2
            | a0 = ptr, d0.W = count, d1.W = i, d5.L = 2^(32-i)-1
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
-    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1
-             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
+    1:       | a0,a1 = Aufwärtszähler Adresse, d0.W = Herabzähler, d1.W = i, d5.L = 2^(32-i)-1
+             | d2.L = Schiebe-Übertrag (obere i Bits, restliche 32-i Bits sind 0)
              | d3.L = Schiebe-Akku
              movel $a0@-,$d3  | neue Daten
              rorl $d1,$d3      | um i Bits rechts rotieren
              movel $d3,$d4
              andl $d5,$d3      | untere 32-i Bits
              eorl $d3,$d4      | obere i Bits
-             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
-             movel $d4,$d2     | neuer Übertrag
+             orl $d2,$d3       | und mit vorigem Übertrag kombinieren
+             movel $d4,$d2     | neuer Übertrag
              movel $d3,$a1@-  | ablegen
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            movel $d2,$d0
@@ -1541,9 +1541,9 @@ C(mulusmall_loop_up:) | Input in d0,a0,d1.W,d2, Output in d0
            movel $sp@(12+8),$a0
            movew $sp@(12+12+2),$d1
            movel $sp@(12+16),$d2
-           addw #0,$d1        | X-Bit löschen
+           addw #0,$d1        | X-Bit löschen
            bras 2f
-    1:       movel $a0@,$d3  | nächstes Digit
+    1:       movel $a0@,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              movel $d3,$a0@+   | Low-Digit ablegen
@@ -1563,9 +1563,9 @@ C(mulu_loop_up:) | Input in d0,a0,a1,d1.W
            movel $sp@(12+8),$a0
            movel $sp@(12+12),$a1
            movew $sp@(12+16+2),$d1
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@+,$d3  | nächstes Digit
+    1:       movel $a0@+,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              movel $d3,$a1@+  | Low-Digit ablegen
@@ -1585,7 +1585,7 @@ C(mulu_loop_up:) | Input in d0,a0,a1,d1.W
            clrl $d5           | 0
            clrl $d2           | carry
            bras 2f
-    1:       movel $a0@+,$d3  | nächstes Digit
+    1:       movel $a0@+,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addl $d2,$d3      | und bisherigen Carry addieren
              addxl $d5,$d4
@@ -1606,13 +1606,13 @@ C(muluadd_loop_up:) | Input in d0,a0,a1,d1.W, Output in d0
            movel $sp@(16+12),$a1
            movew $sp@(16+16+2),$d1
            clrl $d5           | 0
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@+,$d3  | nächstes Digit
+    1:       movel $a0@+,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              addxl $d5,$d4
-             addl $d3,$a1@+   | Low-Digit zum dest-Digit addieren, X als Übertrag
+             addl $d3,$a1@+   | Low-Digit zum dest-Digit addieren, X als Übertrag
              movel $d4,$d2     | High-Digit gibt neuen Carry
     2:       dbra $d1,1b
            addxl $d5,$d2       | letztes X-Bit addieren
@@ -1629,13 +1629,13 @@ C(mulusub_loop_up:) | Input in d0,a0,a1,d1.W, Output in d0
            movel $sp@(16+12),$a1
            movew $sp@(16+16+2),$d1
            clrl $d5           | 0
-           subl $d2,$d2        | carry := 0, X-Bit löschen
+           subl $d2,$d2        | carry := 0, X-Bit löschen
            bras 2f
-    1:       movel $a0@+,$d3  | nächstes Digit
+    1:       movel $a0@+,$d3  | nächstes Digit
              mulul $d0,$d4:$d3  | mit digit multiplizieren
              addxl $d2,$d3     | und bisherigen Carry und X-Bit addieren
              addxl $d5,$d4
-             subl $d3,$a1@+   | Low-Digit vom dest-Digit subtrahieren, X als Übertrag
+             subl $d3,$a1@+   | Low-Digit vom dest-Digit subtrahieren, X als Übertrag
              movel $d4,$d2     | High-Digit gibt neuen Carry
     2:       dbra $d1,1b
            clrl $d0
@@ -1652,7 +1652,7 @@ C(divu_loop_down:) | Input in d0,a0,d1.W, Output in d0
            movew $sp@(8+12+2),$d1
            clrl $d2           | Rest := 0
            bras 2f
-    1:       movel $a0@-,$d3   | nächst-niedriges Digit
+    1:       movel $a0@-,$d3   | nächst-niedriges Digit
              divul $d0,$d2:$d3  | mit Rest kombinieren und durch digit dividieren
              movel $d3,$a0@  | Quotient ablegen, Rest in d2
     2:       dbra $d1,1b
@@ -1670,7 +1670,7 @@ C(divucopy_loop_down:) | Input in d0,a0,a1,d1.W, Output in d0
            movew $sp@(8+16+2),$d1
            clrl $d2           | Rest := 0
            bras 2f
-    1:       movel $a0@-,$d3  | nächst-niedriges Digit
+    1:       movel $a0@-,$d3  | nächst-niedriges Digit
              divul $d0,$d2:$d3  | mit Rest kombinieren und durch digit dividieren
              movel $d3,$a1@-  | Quotient ablegen, Rest in d2
     2:       dbra $d1,1b
@@ -1692,15 +1692,15 @@ C(shiftxor_loop_up:) | Input in a0,a1,d0.W,d1.W
            subw $d1,$d5
            clrl $d2
            | a0 = xptr, a1 = yptr, d0.W = count, d1.W = i, d5.W = 32-i,
-           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
+           | d2.L = Schiebe-Übertrag (i Bits), d3.L = Schiebe-Akku
            bras 2f
     1:       movel $a1@+,$d3  | d3.L = neues Digit
              movel $d3,$d4
              lsll $d1,$d4      | um i Bits nach links schieben
-             orl $d2,$d4       | mit vorigem Übertrag kombinieren
+             orl $d2,$d4       | mit vorigem Übertrag kombinieren
              eorl $d4,$a0@+  | 32 Bits ablegen
              movel $d3,$d2
-             lsrl $d5,$d2      | neuen Übertrag bilden
+             lsrl $d5,$d2      | neuen Übertrag bilden
     2:       dbra $d0,1b        | Schleife d0.W mal durchlaufen
            eorl $d2,$a0@
            moveml $sp@+,$d2-$d5