diff --git a/20230601/ad-20230601.txt b/20230601/ad-20230601.txt
index 55b8ebbcfdc054029b1c52f53d327a0228675da0..8469a716ce12dc999c8d4628455465ee5756fdba 100644
--- a/20230601/ad-20230601.txt
+++ b/20230601/ad-20230601.txt
@@ -13,6 +13,7 @@ heute:
    der Treibhausgasemissionen des Pendelverkehrs für die Treibhausgasbilanz der
    Hochschule Bochum. Zum anderen soll die Bekanntheit und Nutzung bestehender
    Mobilitätsangebote abgefragt werden, die die BO klimafreundlicher gestalten.
+--> https://befragung.hs-bochum.de/evasys/online.php?p=LU2AL
 
 RSA, 25.05.2023, 16:20:49
 ~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -74,5 +75,24 @@ als in einer Schleife fortwährend zu multiplizieren?
 
 Aufgabe:
  (a) Gegeben zwei Zahlen b und e (vom Typ int).
-     Berechnen Sie b^3 mittels binärer Exponentiation.
+     Berechnen Sie b^e mittels binärer Exponentiation.
  (b) Dasselbe modulo einer dritten Zahl n (vom Typ int).
+
+Lösung: siehe binexp-*.c 
+
+Addition langer Zahlen, 01.06.2023, 17:37:20
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Siehe: longadd-*.c, longadd-*.s, sum-*.s
+
+Das Addieren mit Übertrag ("carry") ist in Assembler-Sprache einfacher(!)
+als in C.
+
+Addieren mit Übertrag in C mit der GNU Compiler Collection (GCC):
+https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html
+
+Neue Aufgabe: Addieren beliebig langer Zahlen. Siehe: longadd-10.c
+
+Hinweis für die Initialisierung langer Zahlen:
+Um einen String mit einer Dezimalzahl in eine lange Zahl umzuwandeln,
+braucht man bereits funktionierende Langzahlarithmetik.
+Bei Hexadezimalzahlen kann man jeweils eine Hex-Ziffer in 4 Bit umwandeln.
diff --git a/20230601/binary-01.c b/20230601/binary-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..3e5ef726c344403457d41505273f1e3fbb92528e
--- /dev/null
+++ b/20230601/binary-01.c
@@ -0,0 +1,18 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  if (a & mask)
+    printf ("1");
+  else
+    printf ("0");
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binary-02.c b/20230601/binary-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..74e0d42c6551166f28749fff26ab4e286b606ab8
--- /dev/null
+++ b/20230601/binary-02.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  while (mask)
+    {
+      if (a & mask)
+        printf ("1");
+      else
+        printf ("0");
+      mask <<= 1;  /* falsche Richtung */
+    }
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binary-03.c b/20230601/binary-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..b56d0f0a853aca96ea6f3d909c21f4ae0ebd3c3d
--- /dev/null
+++ b/20230601/binary-03.c
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include <stdint.h>
+
+void print_binary (uint32_t a)
+{
+  uint32_t mask = 0x80000000;  /* binär: Eine 1, 31 Nullen */
+  while (mask)
+    {
+      if (a & mask)
+        printf ("1");
+      else
+        printf ("0");
+      mask >>= 1;
+    }
+  printf ("\n");
+}
+
+int main (void)
+{
+  print_binary (42);  /* binär: 101010 */
+  return 0;
+}
diff --git a/20230601/binexp-01.c b/20230601/binexp-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..37ffe827ffd475fd479753e7d68ffb51cfd5f966
--- /dev/null
+++ b/20230601/binexp-01.c
@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+int bin_exp(int b, int e){
+	int ret = 1;
+	uint32_t i = 0x80000000;
+	while (!(i & e)) i >>= 1;
+	while (i > 0) {
+		ret = ret * ret;
+		printf("Q = %d\n", ret);
+		if(e & i){
+			ret = ret * b;
+		}
+		printf("M = %d\n", ret);
+		i >>= 1;
+	}
+	return ret;
+}
+
+int main (void){
+	int b = 2;
+	int e = 18;
+	printf("%d\n", bin_exp(b, e));
+
+	return 0;
+}
diff --git a/20230601/binexp-02.c b/20230601/binexp-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..65f23c9dccc75469ac0e06abe8a8f7727d2ae7fe
--- /dev/null
+++ b/20230601/binexp-02.c
@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <stdint.h>
+
+int bin_exp (int b, int e)
+{
+  int res = 1;
+  int pot = b;
+  uint8_t mask = 1;
+  while (mask <= e)
+    {
+      if (e & mask)
+        res *= pot;
+      pot *= pot;
+      mask <<= 1;
+    }
+  return res;
+}
+
+int main (void)
+{
+  int b = 2;
+  int e = 18;
+  printf ("%d hoch %d = %d\n", b, e, bin_exp (b, e));
+  return 0;
+}
diff --git a/20230601/binexp-03.c b/20230601/binexp-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..2a0a937b0a81f2b56190ddc00e378b76bffb28a3
--- /dev/null
+++ b/20230601/binexp-03.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <inttypes.h>
+
+int bin_exp(int b, int e, int n){
+	int ret = 1;
+	uint32_t i = 0x80000000;
+	while (!(i & e)) i >>= 1;
+	while (i > 0) {
+		ret = (ret * ret) % n;
+		printf("Q = %d\n", ret);
+		if(e & i){
+			ret = (ret * b) % n;
+		}
+		printf("M = %d\n", ret);
+		i >>= 1;
+	}
+	return ret;
+}
+
+int main (void){
+	int b = 2;
+	int e = 18;
+        int n = 42;
+	printf("%d\n", bin_exp(b, e, n));
+
+	return 0;
+}
diff --git a/20230601/longadd-01.c b/20230601/longadd-01.c
new file mode 100644
index 0000000000000000000000000000000000000000..6fc0b3e65752d3740ff7b56bbc1f92b04749abdd
--- /dev/null
+++ b/20230601/longadd-01.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return a + b;
+}
diff --git a/20230601/longadd-01.s b/20230601/longadd-01.s
new file mode 100644
index 0000000000000000000000000000000000000000..692f23464d5a820df37841132c386532fb34453a
--- /dev/null
+++ b/20230601/longadd-01.s
@@ -0,0 +1,14 @@
+	.file	"longadd-01.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	leal	(%rdi,%rsi), %eax
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-02.c b/20230601/longadd-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..a808650c604e386dd9656c7fa3c9b298b1783eb1
--- /dev/null
+++ b/20230601/longadd-02.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a + (uint64_t) b;
+}
diff --git a/20230601/longadd-02.s b/20230601/longadd-02.s
new file mode 100644
index 0000000000000000000000000000000000000000..8844e2b91769d6ee04bd8c285fecb7969bfef05b
--- /dev/null
+++ b/20230601/longadd-02.s
@@ -0,0 +1,16 @@
+	.file	"longadd-02.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	movl	%edi, %edi
+	movl	%esi, %eax
+	addq	%rdi, %rax
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-02.s32 b/20230601/longadd-02.s32
new file mode 100644
index 0000000000000000000000000000000000000000..0d65561a531016f78865755687a8576357aa0a07
--- /dev/null
+++ b/20230601/longadd-02.s32
@@ -0,0 +1,25 @@
+	.file	"longadd-02.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB0:
+	.cfi_startproc
+	pushl	%ebx                 ; (sichere das ebx-Register auf den Stack)
+	.cfi_def_cfa_offset 8
+	.cfi_offset 3, -8
+	movl	8(%esp), %eax        ; lade den Parameter a ins eax-Register (l = 32 Bit)
+	movl	$0, %edx             ; lade eine 0 ins edx-Register (32 Bit)
+	movl	12(%esp), %ecx       ; lade den Parameter b ins ecx-Register (32 Bit)
+	movl	$0, %ebx             ; lade eine 0 ins ebx-Register (32 Bit)
+	addl	%ecx, %eax           ; addiere: eax += ecx. Merke den Übertrag im Carry-Bit.
+	adcl	%ebx, %edx           ; addiere: edx += ebx + Carry-Bit ("add with carry")
+	popl	%ebx                 ; (hole den auf dem Stack gesicherten Wert zurück ins ebx-Register)
+	.cfi_restore 3
+	.cfi_def_cfa_offset 4
+	ret                          ; Rücksprung aus der Funktion. Der Rückgabewert (64 Bit)
+	.cfi_endproc                 ; liegt in den Registern rax/rdx (untere/obere 32 Bit)
+.LFE0:
+	.size	sum, .-sum
+	.ident	"GCC: (Debian 8.3.0-6) 8.3.0"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/20230601/longadd-03.c b/20230601/longadd-03.c
new file mode 100644
index 0000000000000000000000000000000000000000..481f8883ab2abe0e9f153a90c6e8d26c40adda0c
--- /dev/null
+++ b/20230601/longadd-03.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+#include <stdint.h>
+
+uint64_t sum (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a + (uint64_t) b;
+}
+
+int main (void)
+{
+  uint32_t a = 0x80000007;
+  uint32_t b = 0x80000014;
+  uint64_t c = sum (a, b);
+  printf ("0x%08x + 0x%08x = 0x%016lx\n", a, b, c);
+  return 0;
+}
diff --git a/20230601/longadd-04.c b/20230601/longadd-04.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb7de1a67e2c7a2037b59dca4431840540c2aab6
--- /dev/null
+++ b/20230601/longadd-04.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-05.c b/20230601/longadd-05.c
new file mode 100644
index 0000000000000000000000000000000000000000..e0b3bfff0f96518f2293f354287bf79b683465ae
--- /dev/null
+++ b/20230601/longadd-05.c
@@ -0,0 +1,35 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+void sum (uint128_t a, uint128_t b, uint128_t result)
+{
+  result[3] = a[3] + b[3];  /* Fehler: Übertrag ("carry") nicht berücksichtigt! */
+  result[2] = a[2] + b[2];
+  result[1] = a[1] + b[1];
+  result[0] = a[0] + b[0];
+}
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-06.c b/20230601/longadd-06.c
new file mode 100644
index 0000000000000000000000000000000000000000..eb7de1a67e2c7a2037b59dca4431840540c2aab6
--- /dev/null
+++ b/20230601/longadd-06.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint32_t uint128_t[4];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08x 0x%08x 0x%08x 0x%08x", a[0], a[1], a[2], a[3]);
+}
+
+int main (void)
+{
+  uint128_t a = { 0, 0x80000007, 0x12345678, 0x87654321 };
+  uint128_t b = { 0, 0x80000014, 0x98765432, 0x87654321 };
+  /* -------------1-----------------------1------------ */
+  /*              1, 0x0000001b, 0xaaaaaaab, 0x0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-07.c b/20230601/longadd-07.c
new file mode 100644
index 0000000000000000000000000000000000000000..003b37710478f891618f2bdf1e2717ebfaabf121
--- /dev/null
+++ b/20230601/longadd-07.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+void sum (uint128_t a, uint128_t b, uint128_t result)
+{
+  result[1] = a[1] + b[1];  /* Fehler: Übertrag fehlt! */
+  result[0] = a[0] + b[0];
+}
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0x9876543287654321 };
+  /* ----------------------1-------------------1-------- */
+  /*              0x000000010000001b, 0xaaaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Vorsicht, Falle: Die Ausgabe ist korrekt, weil in unserem Beispiel    */
+  print128 (c);     /* der Übertrag nur jeweils innerhalb einer 64-Bit-"Ziffer" stattfindet, */
+  printf ("\n");    /* aber nicht von der rechten "Ziffer" zur linken.                       */
+  return 0;
+}
diff --git a/20230601/longadd-08.c b/20230601/longadd-08.c
new file mode 100644
index 0000000000000000000000000000000000000000..88c19be258c401203a481f1b9ae3430b5084ef20
--- /dev/null
+++ b/20230601/longadd-08.c
@@ -0,0 +1,29 @@
+#include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0x9876543287654321 };
+  /* ----------------------1-------------------1-------- */
+  /*              0x000000010000001b, 0xaaaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Der Fehler von vorhin ist jetzt behoben. Das sehen wir aber nicht, */
+  print128 (c);     /* weil das Beispiel auf das Auftreten dieses Fehlers nicht testet.   */
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-09.c b/20230601/longadd-09.c
new file mode 100644
index 0000000000000000000000000000000000000000..380da2fcb22d48e6b1c3b60469483947aa4d9b12
--- /dev/null
+++ b/20230601/longadd-09.c
@@ -0,0 +1,29 @@
+include <stdio.h>
+#include <stdint.h>
+
+typedef uint64_t uint128_t[2];
+
+extern void sum (uint128_t a, uint128_t b, uint128_t result);
+
+void print128 (uint128_t a)
+{
+  printf ("0x%08lx 0x%08lx 0x%08lx 0x%08lx", a[0] >> 32, a[0] & 0xffffffff, a[1] >> 32, a[1] & 0xffffffff);
+}
+
+int main (void)
+{
+  uint128_t a = { 0x0000000080000007, 0x1234567887654321 };
+  uint128_t b = { 0x0000000080000014, 0xf876543287654321 };
+  /* ----------------------1-------1-----------1-------- */
+  /*              0x000000010000001c, 0x0aaaaaab0eca8642 */
+  uint128_t c;
+  sum (a, b, c);
+  printf ("  ");
+  print128 (a);
+  printf ("\n+ ");
+  print128 (b);
+  printf ("\n= ");  /* Jetzt ist die Ausgabe korrekt, weil die Funktion korrekt rechnet. */
+  print128 (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longadd-10.c b/20230601/longadd-10.c
new file mode 100644
index 0000000000000000000000000000000000000000..d21d20b16a6e8da720b5cf6bf6887769548eac74
--- /dev/null
+++ b/20230601/longadd-10.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#define N 42
+
+/* 42 Zahlen à 64 Bit = 2688-Bit-Zahlen */
+
+typedef uint64_t uintN_t[N];
+
+extern void sum (uintN_t a, uintN_t b, uintN_t result);  /* Übungsaufgabe */
+
+/* Hinweis: Die bisherigen Beispiele verwendeten Big-Endian. Litte-Endian ist besser. */
+
+void printN (uintN_t a)
+{
+  /* Übungsaufgabe */
+}
+
+int main (void)
+{
+  uintN_t a;  /* Übungsaufgabe: Funktion(en) schreiben, um die Zahlen irgendwie */
+  uintN_t b;  /* sinnvoll zu initialisieren, z.B. durch String mit Hex-Ziffern  */
+  uintN_t c;
+  sum (a, b, c);
+  printf ("  ");
+  printN (a);
+  printf ("\n+ ");
+  printN (b);
+  printf ("\n= ");
+  printN (c);
+  printf ("\n");
+  return 0;
+}
diff --git a/20230601/longmul-02.c b/20230601/longmul-02.c
new file mode 100644
index 0000000000000000000000000000000000000000..b6e992bea28ceaf925520c2c8d1c93f52461fe65
--- /dev/null
+++ b/20230601/longmul-02.c
@@ -0,0 +1,6 @@
+#include <stdint.h>
+
+uint64_t product (uint32_t a, uint32_t b)
+{
+  return (uint64_t) a * (uint64_t) b;
+}
diff --git a/20230601/sum-05-arm.s b/20230601/sum-05-arm.s
new file mode 100644
index 0000000000000000000000000000000000000000..d86b855450c807aa1c0f232b040c2197bfbd870b
--- /dev/null
+++ b/20230601/sum-05-arm.s
@@ -0,0 +1,45 @@
+	.arch armv7-a
+	.eabi_attribute 28, 1
+	.eabi_attribute 20, 1
+	.eabi_attribute 21, 1
+	.eabi_attribute 23, 3
+	.eabi_attribute 24, 1
+	.eabi_attribute 25, 1
+	.eabi_attribute 26, 2
+	.eabi_attribute 30, 1
+	.eabi_attribute 34, 1
+	.eabi_attribute 18, 4
+	.file	"longadd-05.c"
+	.text
+	.align	1
+	.global	sum
+	.arch armv7-a
+	.syntax unified
+	.thumb
+	.thumb_func
+	.fpu vfpv3-d16
+	.type	sum, %function
+sum:
+	@ args = 0, pretend = 0, frame = 0
+	@ frame_needed = 0, uses_anonymous_args = 0
+	@ link register save eliminated.
+	push	{r4}
+	ldr	r3, [r0, #12]  # r3 = a[3]
+	ldr	r4, [r1, #12]  # r4 = b[3]        # void sum (uint128_t a, uint128_t b, uint128_t result)
+	add	r3, r3, r4     # r3 += r4         # {
+	str	r3, [r2, #12]  # result[3] = r3   #   result[3] = a[3] + b[3];  /* Fehler: Übertrag ("carry") nicht berücksichtigt! */
+	ldr	r3, [r0, #8]                      #   result[2] = a[2] + b[2];
+	ldr	r4, [r1, #8]                      #   result[1] = a[1] + b[1];
+	add	r3, r3, r4     # durch "adc"      #   result[0] = a[0] + b[0];
+	str	r3, [r2, #8]   # ersetzen, dann   # }
+	ldr	r3, [r0, #4]   # mit Übertrag
+	ldr	r4, [r1, #4]
+	add	r3, r3, r4
+	str	r3, [r2, #4]
+	ldr	r3, [r0]
+	ldr	r1, [r1]
+	add	r3, r3, r1
+	str	r3, [r2]
+	ldr	r4, [sp], #4
+	bx	lr
+	.size	sum, .-sum
diff --git a/20230601/sum-06.s b/20230601/sum-06.s
new file mode 100644
index 0000000000000000000000000000000000000000..7693fe32214ea6e8e2559cfb394955245bd109b9
--- /dev/null
+++ b/20230601/sum-06.s
@@ -0,0 +1,23 @@
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movl	12(%rsi), %eax
+	addl	12(%rdi), %eax
+	movl	%eax, 12(%rdx)
+	movl	8(%rsi), %eax
+	adcl	8(%rdi), %eax    # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, 8(%rdx)
+	movl	4(%rsi), %eax
+	adcl	4(%rdi), %eax    # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, 4(%rdx)
+	movl	(%rsi), %eax
+	adcl	(%rdi), %eax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movl	%eax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.1,"aMS",@progbits,1
diff --git a/20230601/sum-07-arm.s b/20230601/sum-07-arm.s
new file mode 100644
index 0000000000000000000000000000000000000000..045ad3a925cbf991868ceaeb6a12f81ca2d4df25
--- /dev/null
+++ b/20230601/sum-07-arm.s
@@ -0,0 +1,45 @@
+	.arch armv7-a
+	.eabi_attribute 28, 1
+	.eabi_attribute 20, 1
+	.eabi_attribute 21, 1
+	.eabi_attribute 23, 3
+	.eabi_attribute 24, 1
+	.eabi_attribute 25, 1
+	.eabi_attribute 26, 2
+	.eabi_attribute 30, 1
+	.eabi_attribute 34, 1
+	.eabi_attribute 18, 4
+	.file	"longadd-07.c"
+	.text
+	.align	1
+	.global	sum
+	.arch armv7-a
+	.syntax unified
+	.thumb
+	.thumb_func
+	.fpu vfpv3-d16
+	.type	sum, %function
+sum:
+	@ args = 0, pretend = 0, frame = 0
+	@ frame_needed = 0, uses_anonymous_args = 0
+	@ link register save eliminated.
+	push	{r4, r5, r6}
+	ldr	r3, [r0, #8]
+	ldr	r4, [r0, #12]
+	ldr	r5, [r1, #8]
+	ldr	r6, [r1, #12]
+	adds	r3, r3, r5
+	adc	r4, r6, r4
+	str	r3, [r2, #8]
+	str	r4, [r2, #12]
+	ldr	r3, [r0]
+	ldr	r0, [r0, #4]
+	ldr	r4, [r1]
+	ldr	r1, [r1, #4]
+	adds	r3, r3, r4
+	adc	r0, r1, r0
+	str	r3, [r2]
+	str	r0, [r2, #4]
+	pop	{r4, r5, r6}
+	bx	lr
+	.size	sum, .-sum
diff --git a/20230601/sum-08.s b/20230601/sum-08.s
new file mode 100644
index 0000000000000000000000000000000000000000..7370fe6c040f0a3276e2e39ab0819616ff1cb606
--- /dev/null
+++ b/20230601/sum-08.s
@@ -0,0 +1,18 @@
+	.file	"longadd-07.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movq	8(%rsi), %rax
+	addq	8(%rdi), %rax
+	movq	%rax, 8(%rdx)
+	movq	(%rsi), %rax
+	adcq	(%rdi), %rax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movq	%rax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.8,"aMS",@progbits,1
diff --git a/20230601/sum-09.s b/20230601/sum-09.s
new file mode 100644
index 0000000000000000000000000000000000000000..7370fe6c040f0a3276e2e39ab0819616ff1cb606
--- /dev/null
+++ b/20230601/sum-09.s
@@ -0,0 +1,18 @@
+	.file	"longadd-07.c"
+	.text
+	.globl	sum
+	.type	sum, @function
+sum:
+.LFB11:
+	.cfi_startproc
+	movq	8(%rsi), %rax
+	addq	8(%rdi), %rax
+	movq	%rax, 8(%rdx)
+	movq	(%rsi), %rax
+	adcq	(%rdi), %rax     # adc statt add: Übertrag ("carry") berücksichtigen
+	movq	%rax, (%rdx)
+	ret
+	.cfi_endproc
+.LFE11:
+	.size	sum, .-sum
+	.section	.rodata.str1.8,"aMS",@progbits,1